Zamiana dziesietny na u2

Witam.
Pascala ucze sie od niedawna i jestem jeszcze zielony...
Wie moze ktos jak napisac program, ktory bedzie zamienial liczby z systemu dziesietnego na U2? te ujemne rowniez
Pozdrawiam i dzieki za jakakolwiek pomoc

Googluj : http://programex.risp.pl/pliki/teksty/dla_programistow/D_B.html
W górnym linku jest opisane kodowanie U2. A żeby zrealizować to w Pascalu to przyda ci się znajomość dzielenia modulo(w Pascalu mod), czyli reszty z dzielenia np. : 3 mod 2 = 1.
Np. Gdy masz liczbę dziesiętną 33:

a:integer;
a:=33;
write('0'); /*piszemy zero bo liczby dodatnie w U2 maja pierwszy bit zero a ujemne 1*/
WHILE a>0 DO
BEGIN
 write(a MOD 2);
 a:=a/2;
END;

Ostatni raz w Pascalu pisałem pare ładnych lat temu ale mam nadzieję, że połapiesz się o co chodzi. Kodowanie ujemnych liczb w U2 masz opisane w górnym linku, robi się je podobnie.

Ma przeliczac liczby z przedzialu (-128..127) a wiec:

 
PROGRAM u2;
var cyfry : Array[0..7] of Integer;
x, i : Integer;
begin
repeat
writeln('Podaj liczbe calkowita');
readln(x)
until x >= 0;
for i:=0 to 7 do cyfry[i]:=0;
i:=1;
while x>0 do
begin
cyfry[8-i]:=x mod 2;
x:=x div 2;
inc(i)
end;
i:=1; while (cyfry[i]=0) and (i<7) do inc(i);
write('W zapisie dwojkowym = ');
while i<=7 do
begin
write(cyfry[i]);
inc(i);
end;
writeln;
readln;
end.

W jakis sposob zrobic aby liczbe wyswietlalo na 8 bitach? Oraz aby dla liczby ujemnej negowalo wynik i dodawalo 1 bit ?...
np jesli mamy liczbe 78, czyli 01001110 po negacji bedzie 10110001 i dodaje sie 1 bit czyli 00000001
10110001
+
00000001 i mamy 10110010 co oznacza -78

Pozdrawiam

{
  Program zamienia liczby rzeczywiste w różnych systemach na inne ;-)
  "Szymek" Świerkosz
}


{ deklaracja cyfr }
const digits:string=('0123456789ABCDEFGHIJKLMNOPQRST');

function ExcludeTrailingZeros(s:string):string;
{ funkcja obcina zera na końcu stringa }
var i:byte;
begin
  for i:=length(s) downto 1 do
    if s[i] = '0' then delete(s, i, 1)
    else break;
    
  ExcludeTrailingZeros:=s;
end;

function decode(const Base:byte; const Number:string):real;
{ funkcja zamienia liczbę w `dziwnym` zapisie na `normalny` }
{ funkcja NIE sprawdza poprawności liczby }

  function convert(const s:string):longint;
  var Column:longint;
      Result:longint;
      i:byte;
  begin
    Result:=0;
    {`mnożnik` w systemie pozycyjnym}
    Column:=1;
    for i:=Length(s) downto 1 do
    begin
      {zamień cyfrę na jej wartość}
      {w Pascalu indeksowanie w stringu zaczyna się od 1}
      Result:= Result + (Pos(s[i], digits) - 1) * Column;
      Column:=Column * Base;
    end;
    {zwróć wynik}
    convert:=Result;
  end;

var Result:real;
    Minus:boolean;
    i:byte;
    Integrity, Fractional:string;

begin
  {zeruj zmienne}
  Result:=0;

  {czy w zapisie wystepuje kropka?}
  i:=Pos('.', Number);
  if i>0 then {jeśli tak}
  begin 
    {część całkowita}
    Integrity:=Copy(Number, 1, i-1);
    {część ułamkowa}
    Fractional:=ExcludeTrailingZeros(Copy(Number, i+1, Length(Number) - i));
  end else
  begin
    {część całkowita}
    Integrity:=Number;
    {część ułamkowa}
    Fractional:='';
  end;

  Minus:=Integrity[1] = '-';
  if Minus then
    {usuń znak - }
    Delete(Integrity, 1, 1);

  {najpierw część ułamkowa}
  if Fractional <> '' then
  begin
    {konwertuj do licznika systemu dziesiętnego}
    Result:=convert(Fractional);
    {zaaplikuj odpowiedni mianownik}
    for i:=1 to Length(Fractional) do
      Result:=Result / Base;
  end;
  {dodaj część całkowitą}
  Result:=Result + convert(Integrity);

  if Minus then Result:=-Result;

  {zwróć wynik}
  decode:=Result;
end;

function encode(const Base:byte; const Number:real):string;
{ funkcja zamienia liczbę w `normalnym` zapisie na dziwny` }

var Result:string;
    Integrity:longint;
    Fractional:real;
    Digit:byte;
    Column:real; 
    i:byte;
    
begin
  if Number = 0 then
  begin
    encode:='0';
    Exit;
  end;

  {zeruj zmienne}
  Result:='';

  {wyodrębnij część całkowitą}
  Integrity:=Round(Int(Number));
  
  while (Integrity>0) do
  begin
    Digit:=Integrity mod Base;
    Integrity:=Integrity div Base;
    {w Pascalu indeksowanie w stringu zaczyna się od 1}
    Result:=digits[Digit+1] + Result;
  end;
  
  {wyodrębnij część ułamkową}
  Fractional:=Abs(Number) - Abs(Int(Number));

  if Fractional <> 0 then
  begin
    Result:=Result+'.';
    {`mnożnik` w systemie pozycyjnym}
    Column:=1 / Base;
    { wykonuj pętlę dopóki `mnożnik` i część ułamkowa będą niezerowe }
    { dokładnośc 15 miejsc po przecinku }
    i:=0;
    while (Column > 0) and (Fractional > 0) and (i < 15)do
    begin
      Digit:=Round(Int(Fractional / Column));
      Fractional:=Fractional - Digit * Column;
      Result:=Result + digits[Digit+1];
      
      Column:=Column / Base;
      Inc(i);
    end;
    Result:=ExcludeTrailingZeros(Result);
    
    if Result[Length(Result)] = '.' then 
      delete(Result, Length(Result), 1);
  end; 
  
  {zwróć wynik}
  encode:=Result;
end;

function ValidBase(const base:byte):boolean;
begin
  ValidBase:=(base>1) and (base<Length(digits));
end;

function UpperCase(s:string):string;
var i:byte;
begin

  for i:=1 to Length(s) do
    s[i] := UpCase(s[i]);

  UpperCase:=s;
end;

var n1:string;
    b1, b2:byte;

begin
  Write('Podaj system wprowadzanej liczby: ');
  Readln(b1);

  if not ValidBase(b1) then
  begin
    Writeln('Nie obsługuję tego systemu!');
    Exit;
  end;

  Write('Podaj liczbę w tym systemie: ');
  Readln(n1);

  n1:=UpperCase(n1);

  Write('Podaj system wyjściowej liczby: ');
  Readln(b2);

  if not ValidBase(b2) then
  begin
    Writeln('Nie obsługuję tego systemu!');
    Exit;
  end;

  Writeln('Liczba w tym systemie: ', encode(b2, decode(b1, n1)));
end.

Mój program zrobiony na zajęciach z informatyki.

Negowanie możesz zrobić tak:

for i:=0 to 7 do
begin
 if cyfry[i]='0' then cyfry[i]:='1'
 else cyfry[i]:='0';
end;

A dodawanie 1 bita :

i:=0;
repeat
 if cyfry[i]='0' then
  begin 
   cyfry[i]:='1';
   i:=8;
  end
 else 
  begin
   cyfry[i]:='0';
   inc(i);
  end;
until i<8;

dzieki wielkie ;)
Ps. Szymek - do tego programu jakas instrukcja by sie przydala ;)