// Program przeliczający liczby zmiennoprzecinkowe.
//-------------------------------------------------
// (C)2005 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//-------------------------------------------------

#include <cmath>
#include <iostream>
#include <string>

using namespace std;

// Funkcja sprawdza poprawność zapisu liczby
// Wejście:
//   s    - zapis liczby w postaci stałoprzecinkowej
//   p    - podstawa systemu
//   intg - true = liczba musi być całkowita
// Wyjście:
//   true, jeśli zapis jest prawidłowy
//------------------------------------------------
bool Test(string s, unsigned p, bool intg)
{
  int i,c;
  bool pc,prz;

  pc = prz = false;
  for(i = 0; i < s.length(); i++)
    switch(s[i])
    {
      case '-' : if(pc  || prz)  return(false); else pc  = true;
      case ' ' : break;
      case ',' : if(prz || intg) return(false); else prz = true;
                 break;
      default :  c = (int)(toupper(s[i])) - 48;
                 if(c > 9) c -= 7;
                 if(c >= p) return false;
                 break;
    }
  return true;
}

// Funkcja oblicza wartość liczby
// Wejście:
//   s - łańcuch znakowy z zapisem liczby
//   p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
//   wartość liczby zapisanej w s
//------------------------------------------------
double Wartosc(string s, unsigned p)
{
  unsigned c,i;
  long double Lc,Lu,w;
  int znak;
  bool u;

  Lc = Lu = 0; znak = 1; w = 1; u = false;
  for(i = 0; i < s.length(); i++)
    switch(s[i])
    {
      case '-' : znak = -1;
      case ' ' : break;
      case ',' : u = true; break;
      default  : c = (int)(toupper(s[i])) - 48;
                 if(c > 9) c -= 7;
                 if(u)
                 {
                   Lu = p * Lu + c; w *= p;
                 }
                 else Lc = p * Lc + c;
                 break;
    }
  return znak * (Lc + Lu / w);
}

// Funkcja oblicza wartość potęgi
// Wejście:
//   a - liczba podnoszona do potęgi
//   n - wartość wykładnika potęgowego
// Wyjście:
//   a^n
//------------------------------------
double Potega(int a, int n)
{
  long double p;

  p = 1;
  while(n > 0)
  {
    p *= a; n--;
  }
  while(n < 0)
  {
    p /= a; n++;
  }
  return(p);
}

// Funkcja znajduje zapis stałoprzecinkowy podanej liczby
// Wejście:
//   L - wartość liczby
//   p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
//   zapis liczby w systemie o podstawie p
//-------------------------------------------------------
string Przelicz(double L, unsigned p)
{
  string sc,su;
  unsigned c;
  long double Lu,Lc;
  bool znak;

  znak = false; sc = su = "";

// Algorytm obsługuje liczby nieujemne. Jeśli więc wartość liczby
// jest ujemna, to zapamiętujemy jej znak i zmieniamy ją na dodatnią

  if(L < 0)
  {
    L = -L; znak = true;
  }

// Wyznaczamy część całkowitą Lc oraz część ułamkową Lu.
// Część ułamkowa zostaje zaokrąglona do około 10 cyfr po
// przecinku.

  Lc = floor(L); Lu = L - Lc;

// Wyznaczamy zapis części całkowitej w sc

  do
  {
    c  = (int)floor(Lc - floor(Lc / p) * p);
    if(c < 10)
      sc = (char)(c + 48) + sc;
    else
      sc = (char)(c + 55) + sc;
    Lc = floor(Lc / p);
  } while(Lc);

// Jeśli część ułamkowa jest niezerowa, to wyznaczamy jej
// zapis w su. Na końcu zapisu usuwamy zera nieznaczące

  if(Lu)
  {
    do
    {
      Lu = Lu * p;
      c = (int)floor(Lu);
      Lu = Lu - c;
      if(c < 10) su += (char)(c + 48); else su += (char)(c + 55);
    } while(Lu && su.length() < 10);
    while((su != "") && (su[su.length()-1] == '0'))
      su.erase(su.length()-1);
    su = "," + su;
  }

// Jeśli konieczne, dodajemy znak liczby i całość łączymy
// w jeden zapis.

  if(znak) sc = "-" + sc;
  return sc + su;
}

//**********************
//*** PROGRAM GŁÓWNY ***
//**********************

main()
{
  double m;
  int c;
  unsigned p1,p2;
  string s1,s2;
  char z[1];

  cout << "Przeliczanie liczb zmiennoprzecinkowych\n"
          "---------------------------------------\n"
          "(C)2005 mgr Jerzy Walaszek  I LO Tarnow\n\n"
          "Podstawa zrodlowa = "; cin >> p1;
  if((p1 > 1) && (p1 < 37))
  {
    cout << "\nMantysa = "; cin >> s1;
    if(Test(s1,p1,false))
    {
      cout << "Cecha   = "; cin >> s2;
      if(Test(s2,p1,true))
      {
        cout << "\nPodstawa docelowa = "; cin >> p2;
        if((p2 > 1) && (p2 < 37))
        {

// Obliczamy wartość liczby. Początkowo mantysa jest równa tej
// wartości, a cecha jest równa 0.

          m = Wartosc(s1,p1) * Potega(p1,(int)Wartosc(s2,p1));
          c = 0;

// Normalizujemy mantysę do przedziału <1,p)

          if(m)
          {
            while(fabs(m) >= p2)
            {
              m /= p2; c++;
            };
            while(fabs(m) < 1 )
            {
              m *= p2; c--;
            }
          }
          cout << endl << s1 << "x10^" << s2 << "(" << p1 << ") = "
               << Przelicz(m,p2) << "x10^" << Przelicz(c,p2)
               << "(" << p2 << ")";
        }
        else cout << "Nieprawidlowa podstawa docelowa";
      }
      else cout << "Nieprawidlowa cecha";
    }
    else cout << "Nieprawidlowa mantysa";
  }
  else cout << "Nieprawidlowa podstawa zrodlowa";
  cout << "\n\nNacisnij ENTER...\n";
  cin.getline(z,1);
  cin.getline(z,1);
}

// Program przeliczający liczby zmiennoprzecinkowe.
//-------------------------------------------------
// (C)2005 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//-------------------------------------------------

program Systemy;

{$APPTYPE CONSOLE}

// Funkcja sprawdza poprawność zapisu liczby
// Wejście:
//   s    - zapis liczby w postaci stałoprzecinkowej
//   p    - podstawa systemu
//   intg - true = liczba musi być całkowita
// Wyjście:
//   true, jeśli zapis jest prawidłowy
//------------------------------------------------
function Test(s : string; p : cardinal; intg : boolean) : boolean;
var
  i,c    : integer;
  pc,prz : boolean;
begin
  Test := true;
  pc := false; prz := false;
  for i := 1 to length(s) do
    case s[i] of
      ' ' : continue;
      '-' : if pc or prz then
            begin
              Test := false; break;
            end
            else pc := true;
      ',' : if prz or intg then
            begin
              Test := false; break;
            end
            else prz := true;
      else
      begin
        c := ord(UpCase(s[i])) - 48;
        if c > 9 then dec(c,7);
        if c >= p then
        begin
          Test := false; break;
        end;
      end;
    end;
end;

// Funkcja oblicza wartość liczby
// Wejście:
//   s - łańcuch znakowy z zapisem liczby
//   p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
//   wartość liczby zapisanej w s
//------------------------------------------------
function Wartosc(s : string; p : cardinal) : real;
var
  Lc,Lu,w : extended;
  c,i     : cardinal;
  znak    : integer;
  u       : boolean;
begin
  Lc := 0; Lu := 0; w := 1; u := false; znak := 1;
  for i := 1 to length(s) do
    case s[i] of
      '-' : znak := -1;
      ',' : u    := true;
      else
      begin
        c := ord(UpCase(s[i])) - 48;
        if c > 9 then dec(c,7);
        if u then
        begin
          Lu := p * Lu + c;
          w  := p * w;
        end
        else Lc := p * Lc + c;
      end;
    end;
  Wartosc := znak * (Lc + Lu / w);
end;

// Funkcja oblicza wartość potęgi
// Wejście:
//   a - liczba podnoszona do potęgi
//   n - wartość wykładnika potęgowego
// Wyjście:
//   a^n
//------------------------------------
function Potega(a,n : integer) : real;
var
  p : extended;
begin
  p := 1;
  while n > 0 do
  begin
    p := p * a;
    dec(n);
  end;
  while n < 0 do
  begin
    p := p / a;
    inc(n);
  end;
  Potega := p;
end;

// Funkcja znajduje zapis stałoprzecinkowy podanej liczby
// Wejście:
//   L - wartość liczby
//   p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
//   zapis liczby w systemie o podstawie p
//-------------------------------------------------------
function Przelicz(L : real; p : cardinal) : string;
var
  sc,su : string;
  c     : cardinal;
  Lc,Lu : extended;
  znak  : boolean;
begin
  znak := false; sc := ''; su := '';

// Algorytm obsługuje liczby nieujemne. Jeśli więc wartość liczby
// jest ujemna, to zapamiętujemy jej znak i zmieniamy ją na dodatnią

  if L < 0 then
  begin
    L    := -L;
    znak := true;
  end;

// Wyznaczamy część całkowitą Lc oraz część ułamkową Lu.
// Część ułamkowa zostaje zaokrąglona do około 10 cyfr po
// przecinku.

  Lc := trunc(L);
  Lu := frac(L);

// Wyznaczamy zapis części całkowitej w sc

  repeat
    c  := trunc(Lc - trunc(Lc / p) * p);
    if c < 10 then
      sc := char(c + 48) + sc
    else
      sc := char(c + 55) + sc;
    Lc := trunc(Lc / p);
  until Lc = 0;

// Jeśli część ułamkowa jest niezerowa, to wyznaczamy jej
// zapis w su. Na końcu zapisu usuwamy zera nieznaczące

  if Lu > 0 then
  begin
    repeat
      Lu := Lu * p;
      c  := trunc(Lu);
      Lu := Lu - c;
      if c < 10 then
        su := su + char(c + 48)
      else
        su := su + char(c + 55);
    until (Lu = 0) or (length(su) = 10);
    while (su <> '') and (su[length(su)] = '0') do
      Delete(su,length(su),1);
    su = "," + su
  end;

// Jeśli konieczne, dodajemy znak liczby i całość łączymy
// w jeden zapis.

  if znak then sc := '-' + sc;
  Przelicz := sc + su;
end;

//**********************
//*** PROGRAM GŁÓWNY ***
//**********************

var
  m     : real;
  c     : integer;
  p1,p2 : cardinal;
  s1,s2 : string;
begin
  writeln('Przeliczanie liczb zmiennoprzecinkowych');
  writeln('---------------------------------------');
  writeln('(C)2005 mgr Jerzy Walaszek  I LO Tarnow');
  writeln;
  write('Podstawa zrodlowa = '); readln(p1);
  if p1 in [2..36] then
  begin
    writeln;
    write('Mantysa = '); readln(s1);
    if Test(s1,p1,false) then
    begin
      write('Cecha   = '); readln(s2);
      if Test(s2,p1,true) then
      begin
        writeln;
        write('Podstawa docelowa = '); readln(p2);
        if p2 in [2..36] then
        begin

// Obliczamy wartość liczby. Początkowo mantysa jest równa tej
// wartości, a cecha jest równa 0.

          m := Wartosc(s1,p1) * Potega(p1,round(Wartosc(s2,p1)));
          c := 0;

// Normalizujemy mantysę do przedziału <1,p>

          if m <> 0 then
          begin
            while Abs(m) >= p2 do
            begin
              m := m / p2;
              inc(c);
            end;
            while Abs(m) < 1 do
            begin
              m := m * p2;
              dec(c);
            end;
          end;
          writeln;
          writeln(s1,'x10^',s2,'(',p1,') = ',
                  Przelicz(m,p2),'x10^',Przelicz(c,p2),'(',p2,')');
        end
        else
          writeln('Nieprawidlowa podstawa docelowa');
      end
      else
        writeln('Nieprawidlowa cecha');
    end
    else
      writeln('Nieprawidlowa mantysa');
  end
  else
    writeln('Nieprawidlowa podstawa zrodlowa');
  writeln;
  writeln('Nacisnij klawisz Enter...');
  readln;
end.

' Program przeliczający liczby zmiennoprzecinkowe.
'-------------------------------------------------
' (C)2005 mgr Jerzy Wałaszek
' I Liceum Ogólnokształcące
' im. K. Brodzińskiego
' w Tarnowie
'-------------------------------------------------

Option Explicit On

Module Module1

  ' Funkcja sprawdza poprawność zapisu liczby
  ' Wejście:
  '   s    - zapis liczby w postaci stałoprzecinkowej
  '   p    - podstawa systemu
  '   intg - True = liczba musi być całkowita
  ' Wyjście:
  '   True, jeśli zapis jest prawidłowy
  '------------------------------------------------
  Public Function Test(ByVal s As String, ByVal p As Integer, _
                       ByVal intg As Boolean) As Boolean
    Dim i, c As Integer
    Dim pc, prz As Boolean

    s = s.ToUpper()
    pc = False : prz = False
    For i = 0 To s.Length() - 1
      Select Case s.Chars(i)
        Case " " : Continue For
        Case "-" : If pc Or prz Then
            Return False
          Else
            pc = True
          End If
        Case "," : If prz Or intg Then
            Return False
          Else
            prz = True
          End If
        Case Else
          c = Asc(s.Chars(i)) - 48
          If c > 9 Then c -= 7
          If c >= p Then Return False
      End Select
    Next
    Return True
  End Function

  ' Funkcja oblicza wartość liczby
  ' Wejście:
  '   s - łańcuch znakowy z zapisem liczby
  '   p - podstawa systemu liczbowego zapisu liczby
  ' Wyjście:
  '   wartość liczby zapisanej w s
  '------------------------------------------------
  Public Function Wartosc(ByVal s As String, ByVal p As Integer) As Double
    Dim Lc, Lu, w As Double
    Dim c, i As UInteger
    Dim znak As Integer, u As Boolean

    s = s.ToUpper()
    Lc = 0 : Lu = 0 : w = 1 : u = False : znak = 1
    For i = 0 To s.Length() - 1
      Select Case s.Chars(i)
        Case "-" : znak = -1
        Case "," : u = True
        Case Else : c = Asc(s.Chars(i)) - 48
          If c > 9 Then c -= 7
          If u Then
            Lu = p * Lu + c : w *= p
          Else
            Lc = p * Lc + c
          End If
      End Select
    Next
    Return znak * (Lc + Lu / w)
  End Function

  ' Funkcja oblicza wartość potęgi
  ' Wejście:
  '   a - liczba podnoszona do potęgi
  '   n - wartość wykładnika potęgowego
  ' Wyjście:
  '   a^n
  '------------------------------------
  Public Function Potega(ByVal a As Integer, ByVal n As Integer) As Double
    Dim p As Double

    p = 1
    While n > 0
      p *= a : n -= 1
    End While
    While n < 0
      p /= a : n += 1
    End While
    Return p
  End Function

  ' Funkcja znajduje zapis stałoprzecinkowy podanej liczby
  ' Wejście:
  '   L - wartość liczby
  '   p - podstawa systemu liczbowego zapisu liczby
  ' Wyjście:
  '   zapis liczby w systemie o podstawie p
  '-------------------------------------------------------
  Public Function Przelicz(ByVal L As Double, ByVal p As Integer) As String
    Dim sc, su As String
    Dim c As UInteger
    Dim Lc, Lu As Double
    Dim znak As Boolean

    znak = False : sc = "" : su = ""

    ' Algorytm obsługuje liczby nieujemne. Jeśli więc wartość liczby
    ' jest ujemna, to zapamiętujemy jej znak i zmieniamy ją na dodatnią

    If L < 0 Then
      L = -L : znak = True
    End If

    ' Wyznaczamy część całkowitą Lc oraz część ułamkową Lu.
    ' Część ułamkowa zostaje zaokrąglona do około 10 cyfr po
    ' przecinku.

    Lc = Int(L) : Lu = L - Lc

    ' Wyznaczamy zapis części całkowitej w sc

    Do
      c = Int(Lc - Int(Lc / p) * p)
      If c < 10 Then
        sc = Chr(c + 48) + sc
      Else
        sc = Chr(c + 55) + sc
      End If
      Lc = Int(Lc / p)
    Loop Until Lc = 0

    ' Jeśli część ułamkowa jest niezerowa, to wyznaczamy jej
    ' zapis w su. Na końcu zapisu usuwamy zera nieznaczące

    If Lu > 0 Then
      Do
        Lu *= p
        c = Int(Lu)
        Lu -= c
        If c < 10 Then
          su += Chr(c + 48)
        Else
          su += Chr(c + 55)
        End If
      Loop Until (Lu = 0) Or (su.Length() = 10)
      su = su.TrimEnd("0")
      su = "," + su
    End If

    ' Jeśli konieczne, dodajemy znak liczby i całość łączymy
    ' w jeden zapis.

    If znak Then sc = "-" + sc
    Return sc + su
  End Function

  Sub Main()

    Dim m As Double
    Dim c, p1, p2 As Integer
    Dim s1, s2 As String

    Console.WriteLine("Przeliczanie liczb zmiennoprzecinkowych")
    Console.WriteLine("---------------------------------------")
    Console.WriteLine("(C)2005 mgr Jerzy Wałaszek  I LO Tarnów")
    Console.WriteLine()
    Console.Write("Podstawa źródłowa = ") : p1 = Val(Console.ReadLine)
    If (p1 >= 2) And (p2 <= 36) Then
      Console.WriteLine()
      Console.Write("Mantysa = ") : s1 = Console.ReadLine
      If Test(s1, p1, False) Then
        Console.Write("Cecha   = ") : s2 = Console.ReadLine
        If Test(s2, p1, True) Then
          Console.WriteLine()
          Console.Write("Podstawa docelowa = ") : p2 = Val(Console.ReadLine)
          If (p2 >= 2) And (p2 <= 36) Then

            ' Obliczamy wartość liczby. Początkowo mantysa jest równa tej
            ' wartości, a cecha jest równa 0.

            m = Wartosc(s1, p1) * Potega(p1, Int(Wartosc(s2, p1)))
            c = 0

            ' Normalizujemy mantysę do przedziału <1,p>

            If m <> 0 Then
              While Math.Abs(m) >= p2
                m /= p2 : c += 1
              End While
              While Math.Abs(m) < 1
                m *= p2 : c -= 1
              End While
            End If
            Console.WriteLine()
            Console.WriteLine("{0}x10^{1}({2}) = {3}x10^{4}({5})", _
                              s1, s2, p1, Przelicz(m, p2), Przelicz(c, p2), p2)
          Else
            Console.WriteLine("Nieprawidłowa podstawa docelowa")
          End If
        Else
          Console.WriteLine("Nieprawidłowa cecha")
        End If
      Else
        Console.WriteLine("Nieprawidłowa mantysa")
      End If
    Else
      Console.WriteLine("Nieprawidłowa podstawa źródłowa")
    End If
    Console.WriteLine()
    Console.WriteLine("KONIEC. Naciśnij dowolny klawisz...")
    Console.ReadLine()

  End Sub

End Module

<html>
  <head>
  </head>
  <body>
    <div align="center">
<form style="BORDER-RIGHT: #ff9933 1px outset;
             PADDING-RIGHT: 4px;
             BORDER-TOP: #ff9933 1px outset;
             PADDING-LEFT: 4px;
             PADDING-BOTTOM: 1px;
             BORDER-LEFT: #ff9933 1px outset;
             PADDING-TOP: 1px;
             BORDER-BOTTOM: #ff9933 1px outset;
             BACKGROUND-COLOR: #ffcc66"
      name="frmprzelicz">
  <h3 id="data_out" style="text-align: center">
    Przeliczanie liczb zmiennoprzecinkowych<br>
    w różnych systemach pozycyjnych
  </h3>
  <p style="TEXT-ALIGN: center">
    (C)2005 mgr Jerzy Wałaszek&nbsp;&nbsp; I LO w Tarnowie
  </p>
  <hr>
  <div align="center">
    <table border="0" cellpadding="4" bgcolor="#FF9933">
      <tr>
        <td align="right">podstawa źródłowa =&nbsp;</td>
        <td>
          <input type="text" name="p1" size="20" value="10"
                 style="text-align: right;"> 
          &nbsp;dziesiętnie
        </td>
      </tr>
      <tr>
        <td align="right">mantysa źródłowa =&nbsp;</td>
        <td>
          <input type="text" name="s1" size="20" value="3,33333333"
                 style="text-align: right">
          &nbsp;źródłowo
        </td>
      </tr>
      <tr>
        <td align="right">cecha źródłowa =&nbsp;</td>
        <td>
          <input type="text" name="s2" size="20" value="-1"
                 style="text-align: right"> 
          &nbsp;źródłowo
        </td>
      </tr>
      <tr>
        <td align="right">podstawa docelowa =&nbsp;</td>
        <td>
          <input type="text" name="p2" size="20" value="3"
                 style="text-align: right;"> 
          &nbsp;dziesiętnie
        </td>
      </tr>
    </table>
    <p style="text-align: center">
      <input type="button" value="Przelicz" name="B1" onclick="main();">
    </p>
    <p style="TEXT-ALIGN: center" id="out_t">...</p>
  </div>
</form>

<script language=javascript>

// Program przeliczający liczby zmiennoprzecinkowe.
//-------------------------------------------------
// (C)2005 mgr Jerzy Wałaszek
// I Liceum Ogólnokształcące
// im. K. Brodzińskiego
// w Tarnowie
//-------------------------------------------------

// Funkcja sprawdza poprawność zapisu liczby
// Wejście:
// s - zapis liczby w postaci stałoprzecinkowej
// p - podstawa systemu
// intg - true = liczba musi być całkowita
// Wyjście:
// true, jeśli zapis jest prawidłowy
//------------------------------------------------
function Test(s,p,intg)
{
  var i,c,pc,prz;

  s = s.toUpperCase();
  pc = prz = false;
  for(i = 0; i < s.length; i++)
    switch(s.charAt(i))
    {
      case '-' : if(pc || prz) return(false); else pc = true;
      case ' ' : break;
      case ',' : if(prz || intg) return(false); else prz = true;
                 break;
      default  : c = s.charCodeAt(i) - 48;
                 if(c > 9) c -= 7;
                 if(c >= p) return(false);
                 break;
    };
  return(true);
}

// Funkcja oblicza wartość liczby
// Wejście:
// s - łańcuch znakowy z zapisem liczby
// p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
// wartość liczby zapisanej w s
//------------------------------------------------
function Wartosc(s,p)
{
  var c,i,Lc,Lu,w,znak,u;

  Lc = Lu = 0; znak = w = 1; u = false; s = s.toUpperCase();
  for(i = 0; i < s.length; i++)
    switch(s.charAt(i))
    {
      case '-' : znak = -1;
      case ' ' : break;
      case ',' : u = true; break;
      default  : c = s.charCodeAt(i) - 48;
                 if(c > 9) c -= 7;
                 if(u)
                 {
                   Lu = p * Lu + c; w *= p;
                 }
                 else Lc = p * Lc + c;
                 break;
    };
  return(znak * (Lc + Lu / w));
}

// Funkcja oblicza wartość potęgi
// Wejście:
// a - liczba podnoszona do potęgi
// n - wartość wykładnika potęgowego
// Wyjście:
// a^n
//------------------------------------
function Potega(a,n)
{
  var p;

  p = 1;
  while(n > 0)
  {
    p *= a; n--;
  };
  while(n < 0)
  {
    p /= a; n++;
  };
  return(p);
}

// Funkcja znajduje zapis stałoprzecinkowy podanej liczby
// Wejście:
// L - wartość liczby
// p - podstawa systemu liczbowego zapisu liczby
// Wyjście:
// zapis liczby w systemie o podstawie p
//-------------------------------------------------------
function Przelicz(L,p)
{
  var sc,su,Lu,Lc,c,znak;

  znak = false; sc = su = "";

// Algorytm obsługuje liczby nieujemne. Jeśli więc wartość liczby
// jest ujemna, to zapamiętujemy jej znak i zmieniamy ją na dodatnią

  if(L < 0)
  {
    L = -L; znak = true;
  };

// Wyznaczamy część całkowitą Lc oraz część ułamkową Lu.
// Część ułamkowa zostaje zaokrąglona do około 10 cyfr po
// przecinku.

  Lc = Math.floor(L); Lu = L - Lc;

// Wyznaczamy zapis części całkowitej w sc

  do
  {
    c = Math.floor(Lc - Math.floor(Lc / p) * p);
    if(c < 10)
      sc = String.fromCharCode(c + 48) + sc;
    else
      sc = String.fromCharCode(c + 55) + sc;
    Lc = Math.floor(Lc / p);
  } while(Lc);

// Jeśli część ułamkowa jest niezerowa, to wyznaczamy jej
// zapis w su. Na końcu zapisu usuwamy zera nieznaczące

  if(Lu)
  {
    do
    {
      Lu = Lu * p;
      c = Math.floor(Lu);
      Lu = Lu - c;
      if(c < 10)
        su += String.fromCharCode(c + 48);
      else
        su += String.fromCharCode(c + 55);
    } while(Lu && su.length < 10);
    while((su != "") && (su.charAt(su.length - 1) == '0'))
      su = su.substring(0,su.length-1);
    su = "," + su;
  };

// Jeśli konieczne, dodajemy znak liczby i całość łączymy
// w jeden zapis.

  if(znak) sc = "-" + sc;
  return(sc + su);
}

//**********************
//*** PROGRAM GŁÓWNY ***
//**********************

function main()
{
  var m,c,p1,p2,s1,s2,t;

  p1 = parseInt(document.frmprzelicz.p1.value);
  if(!isNaN(p1) && (p1 > 1) && (p1 < 37))
  {
    s1 = document.frmprzelicz.s1.value;
    if(Test(s1,p1,false))
    {
      s2 = document.frmprzelicz.s2.value;
      if(Test(s2,p1,true))
      {
        p2 = parseInt(document.frmprzelicz.p2.value);
        if(!isNaN(p2) && (p2 > 1) && (p2 < 37))
        {

// Obliczamy wartość liczby. Początkowo mantysa jest równa tej
// wartości, a cecha jest równa 0.

          m = Wartosc(s1,p1) * Potega(p1,Wartosc(s2,p1));
          c = 0;

// Normalizujemy mantysę do przedziału <1/p,1)

          if(m)
          {
            while(Math.abs(m) >= p2)
            {
              m /= p2; c++;
            };
            while(Math.abs(m) < 1)
            {
              m *= p2; c--;
            };
          };
          t = s1 + " x 10<sup>" + s2 + "</sup><sub>(" +
              p1 + ")</sub> = " +
              Przelicz(m,p2) + " x 10<sup>" +
              Przelicz(c,p2) + "</sup><sub>(" + p2 + ")</sub>";
        }
        else t = "<font color=Red><b>Nieprawidlowa podstawa docelowa</b></font>";
      }
      else t = "<font color=Red><b>Nieprawidłowa cecha</b></font>";
    }
    else t = "<font color=Red><b>Nieprawidłowa mantysa</b></font>";
  }
  else t = "<font color=Red><b>Nieprawidłowa podstawa źródłowa</b></font>";
  document.getElementById("out_t").innerHTML = t;
  return 0;
}

</script>

    </div>
  </body>
</html>