[SP-pm] Do Delphi para Perl - Array Boolean para Real/Int/Word e a volta

Blabos de Blebe blabos at gmail.com
Thu Jul 9 17:32:57 PDT 2009


Olha, eu vou pular as várias ressalvas e tentar ser útil.

Ao invés de usar números, por que você não usa uma string com as letras 0 e 1?

Ttipo:

my $valores = "00011010111010101010100010101";

Com isso:

Você não vai ter que se preocupar com o comprimento binário de um
inteiro ou aramazenar flags em um número em ponto flutuante;
Você não vai ter que se preocupar com a quantidade de valores;
Você vai poder usar as funções length e substr para implementar
funções semelhantes às que estão no pastebin.
Você vai poder converter as listas em escalares e vice-versa, apenas
com split e join.



2009/7/9  <claudio em dpreferencial.com.br>:
> Pessoal, Boa noite!
>
> Ainda estou apanhando naquela questão de passar de números para arrays
> booleanos..
>
> Sem querer abusar, mas já abusando ... rsrs..
>
>
> Se alguém puder me dar umas dicas,
> ou onde posso encontrar estas informações.
>
> Desde já agradeço a todos.
>
> Claudio H.Binaghi
>
> ___________________________________________________
> Segue abaixo como faço em Delphi...
>
> Na verdade são 6 procedimentos que fazem:
>
> Boolean => Real
> Real => Boolean
>
> Boolean => Int
> Int => Boolean
>
> Boolean => Word
> Word => Boolean
> ___________________________________________________
>
> <BEGIN CODE>
>
>
> {****************************************************************************
> * REAL_BOOLEAN : Transforma uma variavel REAL em posições de uma matriz do
> *
> *                tipo Boolean.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (48 elementos), passada como parametro
> *
> *            VAR, que recebe o resultado da transformação.
> *
> *        R = número REAL  a ser "transformado" em posições booleanas.
> *
> ****************************************************************************}
> procedure REAL_BOOLEAN{(var B:TIPO_BOOLEAN_REAL;R:Real)};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var I,J : Byte;
>     BY  : array[1..6] of Byte Absolute R;
> Begin
>   FillChar(B,SizeOf(B),0);
>   For I:=1 to 6 do
>     If BY[I]<>0 then For J:=1 to 8 do
>       B[8*(I-1)+J]:=Boolean(BITS[J] and BY[I]);
> End;
>
> {****************************************************************************
> * INT_BOOLEAN : Transforma uma variavel INTEGER em posições de uma matriz
> *
> *                do tipo Boolean.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (16 elementos), passada como parametro
> *
> *            VAR, que recebe o resultado da transformação.
> *
> *        I = número INTEGER  a ser "transformado" em posições booleanas.
> *
> ****************************************************************************}
> procedure INT_BOOLEAN{(var B:TIPO_BOOLEAN_INT;I:Integer)};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var J,K : Byte;
>     BY  : array[1..2] of Byte Absolute I;
> Begin
>   FillChar(B,SizeOf(B),0);
>   For J:=1 to 2 do
>     If BY[J]<>0 then For K:=1 to 8 do
>       B[8*(J-1)+K]:=Boolean(BITS[K] and BY[J]);
> End;
>
> {****************************************************************************
> * WORD_BOOLEAN : Transforma uma variavel WORD em posições de uma matriz do
> *
> *                tipo Boolean.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (16 elementos), passada como parametro
> *
> *            VAR, que recebe o resultado da transformação.
> *
> *        W = número WORD  a ser "transformado" em posições booleanas.
> *
> ****************************************************************************}
> procedure WORD_BOOLEAN{(var B:TIPO_BOOLEAN_INT;W:WORD)};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var J,K : Byte;
>     BY  : array[1..2] of Byte Absolute W;
>
> Begin
>   FillChar(B,SizeOf(B),0);
>   For J:=1 to 2 do
>     If BY[J]<>0 then For K:=1 to 8 do
>       B[8*(J-1)+K]:=Boolean(BITS[K] and BY[J]);
> End;
>
> {****************************************************************************
> * BOOLEAN_REAL : Retorna um número REAL obtido de um vetor Booleano do tipo
> *
> *                TIPO_BOOLEAN_REAL.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (48 elementos) a ser "transformado".
> *
> ****************************************************************************}
> function BOOLEAN_REAL{(B:TIPO_BOOLEAN_REAL):Real};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var I,J : Byte;
>     BY  : array[1..6] of Byte;
>     R   : Real Absolute BY;
>
> Begin
>   FillChar(BY,6,0);
>   For I:=1 to 6 do
>     For J:=1 to 8 do
>       If B[8*(I-1)+J] then BY[I]:=BY[I]+BITS[J];
>   Result:=R;
> End;
>
> {****************************************************************************
> * BOOLEAN_INT : Retorna um número INTEGER obtido de um vetor Booleano do
> *
> *               tipo TIPO_BOOLEAN_INT.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (16 elementos) a ser "transformado".
> *
> ****************************************************************************}
> function BOOLEAN_INT{(B:TIPO_BOOLEAN_INT):Integer};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var I,J : Byte;
>     BY  : array[1..2] of Byte;
>
> Begin
>   FillChar(BY,2,0);
>   For I:=1 to 2 do
>     For J:=1 to 8 do
>       If B[8*(I-1)+J] then BY[I]:=BY[I]+BITS[J];
>    If LongInt((BY[2] shl 8)+BY[1])>32767 then
>      Result:=Integer(((BY[2] shl 8)+BY[1])-65536)
>    else
>      Result:=(BY[2] shl 8)+BY[1];
> End;
>
> {****************************************************************************
> * BOOLEAN_WORD : Retorna um número WORD obtido de um vetor Booleano do tipo
> *
> *                TIPO_BOOLEAN_INT.
> *
> *****************************************************************************
> * Input: B = matriz (vetor) Boolean (16 elementos) a ser "transformado".
> *
> ****************************************************************************}
> function BOOLEAN_WORD{(B:TIPO_BOOLEAN_INT):Word};
> const BITS : array[1..8] of Byte = (1,2,4,8,16,32,64,128);
> var I,J : Byte;
>     BY  : array[1..2] of Byte;
>     N   : Word Absolute BY;
> Begin
>   FillChar(BY,2,0);
>   For I:=1 to 2 do
>     For J:=1 to 8 do
>       If B[8*(I-1)+J] then BY[I]:=BY[I]+BITS[J];
>   BOOLEAN_WORD:=N;
> End;
> <END CODE>
>
>
>
>
>
>
>
> ----- Original Message -----
> From: claudio em dpreferencial.com.br
> To: saopaulo-pm em mail.pm.org
> Sent: Thursday, July 09, 2009 12:36 PM
> Subject: Re: [SP-pm] Problemas numa comparação
>
> Gostei do exemplo que vc colou lá no Pastebin..
>
> ótimo código, bem limpo e simples...
>
> VIvendo e aprendendo,
> valeu pela dica..
>
> abs
>
>
> ----- Original Message -----
> From: Solli Honorio
> To: saopaulo-pm em mail.pm.org
> Sent: Wednesday, July 08, 2009 11:30 PM
> Subject: Re: [SP-pm] Problemas numa comparação
> Meu querido, tire o sotaque de C e coloque o sotaque de Perl, então :
>
> ... de :
> <code>
>
> my $num = 0;
> for (my $i = 0; $i < 8; $i++) {
>     if ($options[$i] eq "S") {
>         $num = set_bit($num, $i);
>     }
> }
>
> </code>
>
> para ... :
> <code>
>
> for  my $i ( 0..7 ) {
>     if ($options[$i] eq "S") {
>         $num = set_bit($num, $i);
>     }
> }
>
> </code>
>
> 2009/7/8 Blabos de Blebe <blabos em gmail.com>
>>
>> 6000 campos? 200000 campos?
>>
>> O que é um campo, nesse contexto? Não conheço o tal do SPSS.
>>
>> Você usa algum banco de dados, tipo MySQL, Postgres?
>>
>> Mas voltando ao assunto?
>>
>> Pelo que eu entendi, denovo supondo, você tem algo como:
>>
>> ----------| Maçã | Laranja | Abacaxi | Banana
>> Wesley    | Não  | Sim     | Não     | Não
>> Solli     | Não  | Sim     | Sim     | Não
>> Montovani | Não  | Não     | Não     | Sim
>>
>> E quer transformar em:
>>
>> ----------| Frutas |
>> Wesley    | 4      |
>> Solli     | 6      |
>> Montovani | 1      |
>>
>> Neste caso, me veio à cabeça algo assim:
>>
>> http://pastebin.com/m729e79c7
>>
>> Abraços
>>
>> 2009/7/8 <claudio em dpreferencial.com.br>
>> >
>> > A todos boa noite!
>> >
>> > Soli,
>> > valeu a intenção, mas assim não rola..
>> > já resolvi isto com & mesmo...
>> >
>> > Estou passando o meu sistema que é em Delphi..mas...
>> > sou novato total em Perl...rsrs...
>> >
>> >
>> > Respondendo a sua pergunta:
>> > ________________
>> > Um breve histórico:
>> >
>> > Eu trabalho com processamento de pesquisas de mercado. (tabulação)
>> >
>> > No começo trabalhei muito anos com Statiscs SPSS, Statiscs ... (com
>> > estes programas as bases ficavam realmente gigantes..rsrs..200.000
>> > campos..rsrs)
>> > acabei desenvolvendo meu próprio sistema de tabulação.
>> >
>> > Desenvolvi um formato para o meu arquivo de dados,
>> > levando em consideração minhas necessidades, tais como:
>> >
>> > - conteúdo criptografado.
>> > - tamanho final do arquivo de base.
>> > - quantidade final de campos na base.
>> > - base não normalizada = campos multivalorados e dependentes..
>> > - conteúdo dos campos: numérico.
>> >
>> > levando em consideração que:
>> > - 80% dos campos de uma pesquisa são campos numéricos e RM (respostas
>> > múltiplas=campos multivalorados)
>> >   Ex:
>> >   Quais frutas vc gosta:
>> >   1 - abacaxi
>> >   2 - Mamão
>> >   3 - abacate....  até o código 50.
>> >
>> >   um fulano responde os códigos 2/3/4/9/10/15
>> >
>> >   num buffer(array de boleanos) eu marco true nestas posição e gravo.
>> >
>> > Veja, no SPSS ou em outras bases "normais" eu precisaria de 15 campos
>> > para guardar as informações,
>> > quando que eu guardo num campo só..de tamanho bem pequeno...rsrs..
>> >
>> > (não percebeu meu nome ..rsrs =>  Binaghi = Binário..rsrs.. aqui só rola
>> > um neurônio, que de vez em quando resolve ficar True..rsrs)
>> > ____________________________________________________
>> > ____________________________________________________
>> >
>> > (é um código totalmente grosso..mas funfa..rsrs)
>> >
>> > É assim que eu faço:
>> >
>> > Leio o arq:
>> >
>> >   open(tap,"<$PathHtdocs");
>> >   binmode tap;
>> >       my ($buf, $data, $n, @cont);
>> >       while (($n = read tap, $data, $x) != 0) {
>> >           print "$n bytes read\n";
>> >          $buf .= $data;
>> >       }
>> >        print "$buf";
>> >   close(tap);
>> >  @cont=split(//,$buf);
>> >
>> > Comparo o conteúdo:
>> >
>> >   push (@byt,1);
>> >   push (@byt,2);
>> >   push (@byt,4);
>> >   push (@byt,8);
>> >   push (@byt,16);
>> >   push (@byt,32);
>> >   push (@byt,64);
>> >   push (@byt,128);
>> >   my @res;
>> >   my $RecCount=$n*8;
>> >   for($a=1;$a<=$RecCount+1;$a++){
>> >        push (@res,0);
>> >   }
>> >   my $pos=0;
>> >   for($a=1;$a<=$n;$a++){
>> >     $val=$cont[$a];
>> > print "----> testa valor $a:=$cont[$a]<br>\n";
>> >     if(ord($val)!=0){
>> >       for($k=0;$k<=7;++$k){
>> >           $pos=8*($a-1)+$k+1;
>> >           $ord=ord($val);
>> >           if(ord($val) & $byt[$k]) {
>> >             $res[$pos]=1;
>> >             $r=ver_conteudo(ord($val),$byt[$k]);
>> > print "----> res[$pos]:=1 / $r<br>\n";
>> >           }
>> >       }
>> >     }
>> >   }
>> > ____________________________________________________
>> > ____________________________________________________
>> >
>> > Esse formato é para as respostas no formato de códigos,
>> > os textos, destes códigos, ficam guardados em outro arquivo..
>> > Tipo na base normal se guarda no formato literal: Sim, Não..
>> > na minha base quardo 1, 2 e tenho um texo só para sim e não..
>> >
>> > Sacou...
>> >
>> >
>> > Obrigado pela atenção..
>> >
>> > Abs
>> >
>> > Claudio H.Binaghi
>> > claudio em dpreferencial.com.br
>> > 5511 3288.4840
>> >
>> >
>> >
>> >
>> >
>> >
>> > ----- Original Message -----
>> > From: Solli Honorio
>> > To: saopaulo-pm em mail.pm.org
>> > Sent: Wednesday, July 08, 2009 3:32 PM
>> > Subject: Re: [SP-pm] Problemas numa comparação
>> > Claudio, eu não ví que vc já havia encontrado o teu problema, mas
>> > continuo curioso sobre o teu trabalho... mas quero mostra uma outra solução
>> > para o teu problema...
>> >
>> > <code>
>> > sub ver_conteudo {
>> >   return 1 << $_[0] & $_[1] ? 1 : 0;
>> > }
>> >
>> > if ( ver_conteudo(1,6) ) {
>> >   print "Verdadeiro\n";
>> > } else {
>> >   print "Falso\n";
>> > }
>> > </code>
>> >
>> > apesar de não ser tão legível (com certeza percisa de uma explicação), é
>> > muito mais rápido pois não preciso criar um array.
>> >
>> > Solli M. Honório
>> >
>> > 2009/7/8 Solli Honorio <shonorio em gmail.com>
>> >>
>> >> Claudio, eu não o que vc quer cara, não entendi o que vc quis dizer com
>> >> 'É uma comparação feita como entre Bytes como Boolean.', então vou responder
>> >> o que eu acho que deveria ser a tradução do teu código:
>> >>
>> >> <code>
>> >> sub ver_conteudo {
>> >>   my @bits = (1,2,4,8,16,32,64,128);
>> >>   return $bits[1] & $_[0] ? 1 : 0;
>> >> }
>> >>
>> >> if ( ver_conteudo(8) ) {
>> >>   print "Verdadeiro\n";
>> >> } else {
>> >>   print "Falso\n";
>> >> }
>> >> </code>
>> >>
>> >> Agora fiquei curioso, porque e como vc está traduzindo um programa em
>> >> Delphi para Perl ? Isto é para uma empresa ?
>> >>
>> >> Abraços,
>> >>
>> >> Solli M. Honório
>> >>
>> >> 2009/7/8 <claudio em dpreferencial.com.br>
>> >>>
>> >>>
>> >>> Pessoall, Boa tarde!
>> >>>
>> >>> Como sempre, estou precisando de um HELP!!!
>> >>>
>> >>> Estou passando um sistema de Delphi para Perl
>> >>> e não tenho consiguido achar indicação
>> >>> para desenvolver este trecho do código.
>> >>>
>> >>> É uma comparação feita como entre Bytes como Boolean.
>> >>> ________________________________________________________________
>> >>> ________________________________________________________________
>> >>> Segue o trecho do código:
>> >>>
>> >>> Procedure Ver_Conteudo;
>> >>>    const BITS: array[0..7] of Byte = (1,2,4,8,16,32,64,128);
>> >>>    Res:   Boolean;
>> >>> Begin
>> >>>
>> >>>   Res := Boolean ( BITS[1] and 6 );    // Este é o trecho que me
>> >>> interessa,  este resultado dá true.
>> >>>
>> >>>   if (Res) Then ShowMessage('True') else ShowMessage('False');
>> >>>
>> >>> End;
>> >>>
>> >>> ________________________________________________________________
>> >>> ________________________________________________________________
>> >>>
>> >>> Qualquer ajuda/ luz, ajuda muito...
>> >>>
>> >>> desde já agradeço a todos.
>> >>>
>> >>> Abs
>> >>>
>> >>> Claudio H.Binaghi
>> >>> claudio em dpreferencial.com.br
>> >>> 5511 3288.4840
>> >>>
>> >>> _______________________________________________
>> >>> SaoPaulo-pm mailing list
>> >>> SaoPaulo-pm em pm.org
>> >>> http://mail.pm.org/mailman/listinfo/saopaulo-pm
>> >>
>> >>
>> >>
>> >> --
>> >> "o animal satisfeito dorme". - Guimarães Rosa
>> >
>> >
>> >
>> > --
>> > "o animal satisfeito dorme". - Guimarães Rosa
>> >
>> > ________________________________
>> >
>> > _______________________________________________
>> > SaoPaulo-pm mailing list
>> > SaoPaulo-pm em pm.org
>> > http://mail.pm.org/mailman/listinfo/saopaulo-pm
>> >
>> > _______________________________________________
>> > SaoPaulo-pm mailing list
>> > SaoPaulo-pm em pm.org
>> > http://mail.pm.org/mailman/listinfo/saopaulo-pm
>>
>>
>> _______________________________________________
>> SaoPaulo-pm mailing list
>> SaoPaulo-pm em pm.org
>> http://mail.pm.org/mailman/listinfo/saopaulo-pm
>
>
>
> --
> "o animal satisfeito dorme". - Guimarães Rosa
>
> ________________________________
>
> _______________________________________________
> SaoPaulo-pm mailing list
> SaoPaulo-pm em pm.org
> http://mail.pm.org/mailman/listinfo/saopaulo-pm
>
> ________________________________
>
> _______________________________________________
> SaoPaulo-pm mailing list
> SaoPaulo-pm em pm.org
> http://mail.pm.org/mailman/listinfo/saopaulo-pm
>
> _______________________________________________
> SaoPaulo-pm mailing list
> SaoPaulo-pm em pm.org
> http://mail.pm.org/mailman/listinfo/saopaulo-pm
>


More information about the SaoPaulo-pm mailing list