Borland
Delphi 7.0
Personal
Edition | // 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. |
Borland
C++ Builder
6.0
Personal
Edition | // 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);
} |
Microsoft
Visual
Basic 2005
Express
Edition | ' 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 |
| Python | # -*- coding: cp1250 -*-
# Program przeliczający liczby zmiennoprzecinkowe.
#-------------------------------------------------
# (C)2005 mgr Jerzy Wałaszek
# I Liceum Ogólnokształcące
# im. K. Brodzińskiego
# w Tarnowie
#-------------------------------------------------
import string
# 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
#------------------------------------------------
def Test(s, p, intg):
pc = prz = False
s = string.upper(s)
for i in range(len(s)):
x = s[i]
if x == " ": continue
elif x == "-":
if pc or prz: return False
else: pc = True
elif x == ",":
if prz or intg: return False
else: prz = True
else:
c = ord(x) - 48
if c > 9: c -= 7
if c >= p: return False
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
#------------------------------------------------
def Wartosc(s, p):
Lc = Lu = 0.0; w = 1.0; u = False; znak = 1
s = string.upper(s)
for i in range(len(s)):
x = s[i]
if x == "-": znak = -1
elif x == ",": u = True
else:
c = ord(x) - 48
if c > 9: c -= 7
if u:
Lu = p * Lu + c
w *= p
else: Lc = p * Lc + c
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
#------------------------------------
def Potega(a, n):
p = 1.0
while n > 0:
p *= a; n -= 1
while n < 0:
p /= a; n += 1
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
#-------------------------------------------------------
def Przelicz(L, p):
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 = float(int(L)); Lu = L - Lc
# Wyznaczamy zapis części całkowitej w sc
while Lc:
c = int(Lc - int(Lc / p) * p)
if c < 10: sc = chr(c + 48) + sc
else: sc = chr(c + 55) + sc
Lc = float(int(Lc / p))
if sc == "": sc = "0"
# Jeśli część ułamkowa jest niezerowa, to wyznaczamy jej
# zapis w su. Na końcu zapisu usuwamy zera nieznaczące
if Lu:
while Lu and (len(su) < 10):
Lu *= p
c = int(Lu)
Lu -= c
if c < 10: su += chr(c + 48)
else: su += chr(c + 55)
while (su != "") and (su[-1] == "0"): su = su[:-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 ***
#**********************
print "Przeliczanie liczb zmiennoprzecinkowych"
print "---------------------------------------"
print "(C)2005 mgr Jerzy Walaszek I LO Tarnow"
print
p1 = int(raw_input("Podstawa zrodlowa = "))
if (p1 >= 2) and (p1 <= 36):
print
s1 = raw_input("Mantysa = ")
if Test(s1, p1, False):
s2 = raw_input("Cecha = ")
if Test(s2, p1, True):
print
p2 = int(raw_input("Podstawa docelowa = "))
if (p2 >= 2) and (p2 <= 36):
# 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 abs(m) >= p2:
m /= p2; c += 1
while abs(m) < 1:
m *= p2; c -= 1
print
print "%sx10^%s(%d) = %sx10^%s(%d)" % \
(s1, s2, p1, Przelicz(m, p2), Przelicz(c, p2), p2)
else: print "Nieprawidlowa podstawa docelowa"
else: print "Nieprawidlowa cecha"
else: print "Nieprawidlowa mantysa"
else: print "Nieprawidlowa podstawa zrodlowa"
print
raw_input("Nacisnij klawisz Enter...") |
| JavaScript | <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 I LO w Tarnowie
</p>
<hr>
<div align="center">
<table border="0" cellpadding="4" bgcolor="#FF9933">
<tr>
<td align="right">podstawa źródłowa = </td>
<td>
<input type="text" name="p1" size="20" value="10"
style="text-align: right; background-color: #FFFFCC">
dziesiętnie
</td>
</tr>
<tr>
<td align="right">mantysa źródłowa = </td>
<td>
<input type="text" name="s1" size="20" value="3,33333333"
style="text-align: right">
źródłowo
</td>
</tr>
<tr>
<td align="right">cecha źródłowa = </td>
<td>
<input type="text" name="s2" size="20" value="-1"
style="text-align: right">
źródłowo
</td>
</tr>
<tr>
<td align="right">podstawa docelowa = </td>
<td>
<input type="text" name="p2" size="20" value="3"
style="text-align: right; background-color: #FFFFCC">
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> |
1033
