Newsgroup: it.comp.lang.pascal
Titolo: Grattacapo!

Qualcuno mi risolvi questo grattacapo!
Nel programma seguente la procedura
Somma dovrebbe rimpiazzare uno ad
uno i caratteri della stringa C, trattandola
come array di caratteri. Purtroppo questa
pare cessare di essere una stringa: il
programma non funzia e nella finestra
watch la variabile C risulta uguale a cose
come '17'#3#5. Why? Forse la funzione
Chr non e' adatta?
Grazie anticipatamente.
Carmelo.
_____________________________
Program nums;
  Uses Crt;
  Var A,B: String;
  Function Somma(A,B: String): String;
    Var I,K,Riporto: Integer;
        Result: String;
    Begin
      Riporto:=0;
      Result:=A;
      For I:=Length(Result) DownTo 1 Do
        Begin
          K:=Ord(A[I])+Ord(B[I])-96+Riporto;
          If K>=10 Then Riporto:=K Div 10;
          Result[I]:=Chr(K Mod 10);
       (* Result:=Copy(Result,1,I-1)+Chr(K Mod 10)+Copy(Result,I+1,Length(Result)-I); *)
       (* Questo e' un rimpiazzo che non funziona neanche *)
        End;
      Somma:=Result;
    End;
  Begin
   Clrscr;
   Readln(A);
   Readln(B);
   Writeln(Somma(A,B));
   Readln;
  End.

          If K>=10 Then Riporto:=K Div 10;
quindi aggiungerei un
  Else Riporto:=0;


>          Result[I]:=Chr(K Mod 10);
in
  Result[I]:=Chr((K Mod 10)+48);


   Function Somma(A,B: String): String;
ehhehe ma stai pensando a quello che penso io ? :-)
--
Dreadnaut
(Life would be easier if I had the source code)

     Else Insert(Chr(48),A,1);
NOOOOOOOOOOOOOO!!!!!!!!!!!!!!!!!!!!!!!!
Perche'? Perche' non mi avete messo prima
al corrente dell'esistenza della funzione Insert?
Non avete notato che PAS Math e' pieno
zeppo di oscenita' del tipo:
Str:=Copy(Str,1,I-1)+'*'+Copy(Str,I,Length(Str)-I+1);
Perche'???? Cosa ho fatto di male per meritarmi
questo?  Perche'?????  :-((((((
)-: Carmelo :-(

   Result[I]:=Chr((K Mod 10)+48);
E direi che l'errore principale era proprio
questo! Grazie di tutto.
Ciao, Carmelo.

 ehhehe ma stai pensando a quello che penso io ? :-)
Assolutamente no!!!!!!! ^_^
Io non penso. Agisco! :-P
Ecco qui in basso alcune funzioni scritte oggi stesso.
Per ora gestiscono solo numeri interi e manca la
divisione. Cio' che mi preoccupa e' la lentezza
della funzione per la moltiplicazione: se entrambi
i fattori superano le sei cifre il mio P200 MMX
impiega ben 15 secondi per calcolare il prodotto.
Hai qualche idea per sfruttare meglio il processore?
Ciao, Carmelo.
____________________________________
{ This source is to be distributed under the terms
of the GPL - Gnu Public License.
Copyright (C) 2002 Carmelo Spiccia.
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU General
Public License as published by the Free Software
Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will
be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You can find a copy of this license at
http://www.gnu.org/licenses/gpl.txt
 }
Program UltraNum;
  Uses Crt;
  Var A,B: String;
  Function EQ(A,B: String): Boolean;
    Begin
      If A[1]='+' Then Delete(A,1,1);
      If B[1]='+' Then Delete(B,1,1);
      While Length(A)>0 Do
        If A[1]='0' Then Delete(A,1,1) Else Break;
      While Length(B)>0 Do
        If B[1]='0' Then Delete(B,1,1) Else Break;
      EQ:=(A=B);
    End;
  Function NE(A,B: String): Boolean;
    Begin
      If A[1]='+' Then Delete(A,1,1);
      If B[1]='+' Then Delete(B,1,1);
      While Length(A)>0 Do
        If A[1]='0' Then Delete(A,1,1) Else Break;
      While Length(B)>0 Do
        If B[1]='0' Then Delete(B,1,1) Else Break;
      NE:=(A<>B);
    End;
  Function GT(A,B: String): Boolean;
    Var I,K: Integer;
        NegSignA,NegSignB,Res: Boolean;
    Begin
      NegSignA:=(A[1]='-');
      NegSignB:=(B[1]='-');
      If NegSignA Xor NegSignB Then
        Res:=NegSignB
                               Else
        Begin
          If A[1] In ['+','-'] Then Delete(A,1,1);
          If B[1] In ['+','-'] Then Delete(B,1,1);
          While Length(A)<>Length(B) Do
            If Length(A)>Length(B) Then Insert('0',B,1) Else Insert('0',A,1);
          Res:=False; I:=1;
          While (A[I]=B[I]) And (I<Length(A)) Do I:=I+1;
          If A[I]>B[I] Then Res:=True;
          If NegSignA Then Res:=Not Res;
        End;
      GT:=Res;
    End;
  Function LT(A,B: String): Boolean;
    Begin
      LT:=(Not GT(A,B)) And NE(A,B);
    End;
  Function GE(A,B: String): Boolean;
    Begin
      GE:=EQ(A,B) Or GT(A,B);
    End;
  Function LE(A,B: String): Boolean;
    Begin
      LE:=Not GT(A,B);
    End;
  Function NLT(A,B: String): Boolean;
    Begin
      NLT:=EQ(A,B) Or GT(A,B);
    End;
  Function NGT(A,B: String): Boolean;
    Begin
      NGT:=Not GT(A,B);
    End;
  Function NTrunc(A: String): String;
    Begin
      If A[1]='+' Then Delete(A,1,1);
      While Length(A)>0 Do
        If A[1]='0' Then Delete(A,1,1) Else Break;
      If A[1]='.' Then NTrunc:='0'
                  Else NTrunc:=Copy(A,1,Pos('.',A)-1);
    End;
  Function NRound(A: String): String;
    Begin
    End;
  Function NAbs(A: String): String;
    Begin
      If A[1] In ['+','-'] Then Delete(A,1,1);
      While Length(A)>0 Do
        If A[1]='0' Then Delete(A,1,1) Else Break;
      NAbs:=A;
    End;
  Function Opp(A: String): String;
    Begin
      If A[1]='-' Then Delete(A,1,1)
                  Else
        If A[1]='+' Then A[1]:='-' Else A:='-'+A;
      Opp:=A;
    End;
  Function Add(A,B: String): String;
    Var I,K,Riporto: Integer;
        Sub,NegSignA,NegSignB,TmpBool: Boolean;
        TmpSt: String;
    Begin
      Riporto:=0;
      NegSignA:=(A[1]='-');
      NegSignB:=(B[1]='-');
      Sub:=(NegSignA Xor NegSignB);
      If A[1] In ['+','-'] Then Delete(A,1,1);
      If B[1] In ['+','-'] Then Delete(B,1,1);
      While Length(A)<>Length(B) Do
        If Length(A)>Length(B) Then Insert('0',B,1) Else Insert('0',A,1);
      If Sub And GT(B,A) Then
        Begin
          TmpSt:=A; A:=B; B:=TmpSt;
          TmpBool:=NegSignA; NegSignA:=NegSignB; NegSignB:=TmpBool;
        End;
      For I:=Length(A) DownTo 1 Do
        Begin
          If Sub Then K:=Ord(A[I])-Ord(B[I])+Riporto
                 Else K:=Ord(A[I])+Ord(B[I])-96+Riporto;
          If Sub And (K<0) Then
            Begin
              K:=K+10;
              Riporto:=-1;
            End
                           Else
            If K>=10 Then Riporto:=K Div 10 Else Riporto:=0;
          A[I]:=Chr((K Mod 10)+48);
        End;
      If Riporto>0 Then Insert(Chr(Riporto+48),A,1);
      If NegSignA Then Insert('-',A,1);
      Add:=A;
    End;
  Function Sub(A,B: String): String;
    Begin
      Sub:=Add(A,Opp(B));
    End;
  Function Mul(A,B: String): String;
    Var I,Res,TmpSt: String;
    Begin
      Res:='0';
      If NE(A,'0') And NE(B,'0') Then
        Begin
          I:='1';
          If GT(A,B) Then
            Begin
              TmpSt:=A;
              A:=B;
              B:=TmpSt;
            End;
          While LE(I,NAbs(A)) Do
            Begin
              Res:=Add(Res,B);
              I:=Add(I,'1');
            End;
        End;
      Mul:=Res;
    End;
  Function DivR(A,B: String): String;
    Begin
    End;
  Function DivI(A,B: String): String;
    Begin
    End;
  Function NMod(A,B: String): String;
    Begin
    End;
  BEGIN
    Clrscr;
    Write('A = '); Readln(A);
    Write('B = '); Readln(B);
    Writeln('A * B = ',Mul(A,B));
    Readln;
  END.

Hai qualche idea per sfruttare meglio il processore?
Dovresti ricorrere all'assembler, ma non è un problema facile.
Comunque, eccoti una risposta:
http://www.cs.sunysb.edu/~algorith/files/high-precision-arithmetic.shtml
come vedi, una soluzione potrebbe essere "combinare linearmente" i
numeri, ma PARI sembra molto migliore. Ti ispira fare un porting dal
C?
---
Ciao
PV

> Hai qualche idea per sfruttare meglio il processore?
asp... per fare la moltiplicazione non gil farai
mica fare tante addizioni vero ?? :-)


 mica fare tante addizioni vero ?? :-)
ehheh ops non avevo notato il codice nel mex... :-)


)-: Carmelo :-(
Ahhh ecco perche' non usavi mai la Insert, credevo fosse una scelta
ideologica ehehe++
Ringraziamo il grande dio PasMath che migliora le nostre conoscenze e
forse anche le nostre vite ehehe++
Omega e' omega e basta.