Przeliczanie jednostek typu kb KB

Pobierz spakowaną witrynę gorzow-wlkp.pl/linux

Jeżeli pragniesz poznać Linuksa Mandrake (obecnie Mandriva), to... dobrze trafiłeś. Witryna została zauważona przez twórców magazynu KOMPUTER ŚWIAT 5/2004(141) str. 46 poprzez umieszczenie linku oraz magazynu CHIP 4/2004 (str.114) poprzez umieszczenie artykułu opisującego ten serwis internetowy. Jak na hobbystyczną stronę o Linuksie to miłe ;) Acha... na stronie mandrakelinux.pl/informacje podano też link z opisem cytuję "duży zbiór praktycznych informacji o Mandrake" (mam ją w swoim archiwum).

Zapraszam do zadawania pytań na FORUM oraz mailem. Chętnie udzielę (bezpłatnie) odpowiedzi. Oficjalne ceny za jedną poradę na stronie MandrakeSoftPL (mam ją w moim archiwum z dnia 2.05.2004) wahają się od 20 do 350 zł.

KSIĘGA GOŚCI oraz STATYSTYKI ODWIEDZIN.

Na początku muszę oświadczyć, że nie udzieliłem tutaj jednoznacznej i kompletnej odpowiedzi na pytania o przeliczaniach jednostek informatycznych. Powodem jest bałagan, podobny do tego, jaki jeszcze niedawno panował w kodowaniu czcionek narodowych na stronach www. Niniejsza strona zawiera treści akceptowane przez jedne grupy profesorów w szkołach informatycznych, ale trzeba też powiedzieć, że inni wykładowcy stosują inne techniki. Problemem jest proste, zdawałoby się, określenie, czym jest kilo, mega, giga itd.

Dla wielu profesorów normą jest układ SI, gdzie kilo=1000¹=1000, a mega to 1000²=1000000.

Niestety, sprawa się komplikuje, gdyż informatycy znają pojęcie kilo jako 1024. Kilo=1024¹=1024, a mega=1024²=1 048 576

Ci pierwsi uważają, że... nie należy w ogóle przeliczać wartości 1024 (stosujemy wyłącznie 1000). To wygodne podejście, ale na styl chowania głowy w piasek. Przelicznik 1024 istnieje i jakoś trzeba go umieć wyznaczać.
Było kilka pomysłów na rozwiązanie problemu, które nie przyjęły się. Ostatnio widzę w linuksowych programach rodem z USA, że tamtejsi programiści do oznaczenia przelicznika 1024 dodają literkę "i" z prawej strony literki oznaczającej kilo (Ki), mega (Mi) itd. Inaczej mówiąc, K oznacza przelicznik 1000, a Ki (informatyczne) oznacza 1024. Niestety, na polskich uczelniach jest to nieznane i stosowanie takiego rozwiązania na egzaminach, kończy się dla studentów oceną niedostateczną (2011r.).

Na tej stronie zaznajomię Was z, moim zdaniem, najpopularniejszym (choć jak już wspomniałem, nie jedynym) sposobem przeliczania jednostek: kilo pisane małą literką k oznacza 1000, a kilo pisane dużą literką K oznacza 1024.

Bit = najmniejsza jednostka, czyli zero lub jeden w systemie dwójkowym.
Bity oznaczamy w pisowni polskiej małą literą b.
Natomiast w pisowni angielskiej spotykane są dwa rodzaje oznaczeń bitów:
- mała literka b (jak w pisowni polskiej)
- bits , czyli bity (liczba mnoga od angielskiego słowa bit)
Bajt = 8 bitów
Bajty oznaczamy w pisowni polskiej dużą literą B.
Natomiast w pisowni angielskiej bajty (liczba mnoga), to bytes.
Choć nie zajmuję się tutaj wyliczaniem jednostek w odstępach czasowych, myślę, że należy wyjaśnić ewentualną obecność literki s na końcu w skrótach np. Kbps , Kbit/s , Kbs (trzy oznaczenia tego samego, choć Kbs jest rzadziej spotykane). Oznacza to ilość jednostek (Kb - Kilobitów) na sekundę. Uwaga: dostawcy Internetu najczęściej podają prędkość transmisji w kilobitach na sekundę (kb/s lub kbps - kilobits per second), a przeglądarki internetowe generalnie podczas pobierania danych pokazują wartości wyrażone w Kilobajtach na sekundę (KB/s lub Kbytes/s).
Musimy być czujni i nie pomylić literki "s" oznaczającej liczbę mnogą (taka jest gramatyka języka angielskiego), z literką "s" symbolizującą sekundę.

kilo (pisane z małej litery) = mnożnik 1000 (lub inaczej mnożnik 1000¹)
Kilo (pisane z dużej litery) = mnożnik 1024 (lub inaczej mnożnik 1024¹)
mega (pisane z małej litery) = mnożnik 1000² (czyli 1000 do potęgi 2)
Mega (pisane z dużej litery) = mnożnik 1024²
giga (pisane z małej litery) = mnożnik 1000³
Giga (pisane z dużej litery) = mnożnik 1024³

Nieszczęście polega na tym, że ten sam przedrostek kilo/mega/giga w zależności od pisowni (mała lub duża pierwsza litera) jest związany z innym mnożnikiem 1000 lub 1024 (do potęgi 1, 2, 3). Pół biedy, gdy nazwę jednostki mamy na piśmie, lecz co zrobić, gdy słyszymy słowo "kilo(...)". Ucho przecież nie odróżnia małej i dużej litery "K" w słowie "Kilo".

Dodatkowo komplikacje wywołuje niekonsekwencja w pisowni polsko/angielskiej:

bajty - w polskim skrócie B literka B jest duża, natomiast w angielskim skrócie bytes literka b jest mała

bity - w polskim skrócie b literka b jest mała, natomiast w pisowni angielskiej spotykane są wymiennie dwa rodzaje oznaczeń bitów: bits (w języku angielskim bit z dodatkiem literki s oznacza liczbę mnogą, czyli bits) oraz mała literka b.
Niestety, dla nieznających angielskiego, kłopotliwym jest zrozumienie, kiedy literka "s" oznacza liczbę mnogą, a kiedy symbolizuje sekundę.

1 KB = 1024 B (KB - kilobajt)
1 MB = 1024 KB (MB - megabajt)
1 GB = 1024 MB (GB - gigabajt)
1 TB = 1024 GB (TB - terabajt)
1 PB = 1024 TB (PB - petabajt)
1 EB = 1024 PB (EB - eksabajt)
1 ZB = 1024 EB (ZB - zettabajt)
1 YB = 1024 ZB (YB - jottabajt)
1 BB = 1024 YB (BB - brontobajt)

Największą trudnością podczas wyliczeń stał się... wybór pomiędzy dwiema TECHNIKAMI wyliczeń.

Algorytm zastosowany w poniższym formularzu jest następujący:
- przeliczenie wprowadzonych danych do bitów
- przeliczenie z bitów do końcowych jednostek

Mamy do wyboru dwa sposoby wyliczania:

obliczyć wynik tradycyjnie, czyli z możliwie największą dokładnością po przecinku
z podanej wartości (np. MB) wyliczyć ilość bitów BEZ PRZECINKA i dopiero tak "okrojony" wynik przemnożyć przez współcznynniki

W wersji A nie martwimy się, czy podana wartość np. 23,45MB da pełne bity bez przecinka, zwracając uwagę na DOKŁADNOŚĆ MATEMATYCZNĄ.
W wersji B mamy wynik matematycznie "niedokładny", ale z technicznego punktu widzenia najbardziej obiektywny. Pamietajmy bowiem, że bitów nie wolno podawać w ułamku z prostego powodu: gdyż bit to najmniejsza, niepodzielna jednostka (0 lub 1 w systemie dwójkowym). Poniższy formularz jest wykonany wg projektu A.

Znając podstawowe reguły możemy wykonać pierwsze wyliczenia:

Wpis poprawny matematycznie:
1 KB (z ang. Kbytes) = 1024 * 8 b = 8192 b = 8,192 kb (z ang. kbits lub kb)
Wpis niepoprawny matematycznie:
1 KB (z ang. Kbytes) = 1024 * 8 = 8192 = 8,192 kb (z ang. kbits lub kb)

Inny wpis - poprawny :)
1 KB = 1/1024 MB = 0,0009765625 MB

W ramach projektowania skryptu automatycznie przeliczającego jednostki przyjąłem, że dane będą wprowadzane w: b, B, kb, Kb, kB, KB, mb, Mb, mB, MB, gb, Gb, gB, GB (w takim też zakresie jednostek będzie można uzyskać wyniki). Poniższe schematy wyliczeń są proste: po sprowadzeniu danych do najmniejszej jednostki (przeliczam całość na bity), mnożę je przez współczynniki otrzymując docelową jednostkę. Wyliczenia są rozpisane w formie nieskróconej, co ułatwia ich zrozumienie, ale i (niestety) grozi kąśliwymi uwagami matematyków lubiących skrótową formę.

Jeżeli czasami gubisz się w temacie, to zapewniam, że przeliczanie jednostek jest materiałem przeznaczonym głównie dla narwanych egzaminatorów w szkołach informatycznych. Normalny użytkownik ma pod ręką programy i specjalistyczne kalkulatory. Poniższe podaję wyłącznie, by ułatwić zrozumienie sposobu wyliczeń zastosowanych w formularzu oraz programiku kb (pod Windows).

Autor nie ponosi ŻADNEJ odpowiedzialności za błędy wynikłe z nieprawidlowości działania programu oraz formularza. Autor wykonał program WYŁĄCZNIE na swój prywatny użytek i w dobrej wierze udostępnił wyniki pracy.

Uwaga: jeżeli w wyniku pojawi się znak (y)E-(x) (podobnie jak w kalkulatorze, gdy brakuje cyfr na wyświetlaczu), to oznacza, że liczba y jest pomnożona przez 10^x.

Wpisz wartość do przeliczeń:

Aby ręcznie przeliczyć jednostki, skorzystaj z poniższych wzorców. Zamiast znaku ? wpisz dane do przeliczeń.
Jednostka wprowadzanych danych jest opisana po polsku i angielsku: pl | ang.

? b | bits (bitów | bits) =
= ?/1000 kb
= ?/1000/1000 mb
= ?/1000/1000/1000 gb
= ?/1024 Kb
= ?/1024/1024 Mb
= ?/1024/1024/1024 Gb
= ?/8 B
= (?/1000)/8 kB
= (?/1000/1000)/8 mB
= (?/1000/1000/1000)/8 gB
= (?/1024)/8 KB
= (?/1024/1024)/8 MB
= (?/1024/1024/1024)/8 GB

? kb | kbits (kilobitów | kilobits) =
= ?*1000 b
= [(?*1000)/1000]/1000 mb
= {[(?*1000)/1000]/1000}/1000 gb
= (?*1000)/1024 Kb
= [(?*1000)/1024]/1024 Mb
= {[(?*1000)/1024]/1024}/1024 Gb
= (?*1000)/8 B
= [(?*1000)/1000]/8 kB
= {[(?*1000)/1000]/1000}/8 mB
= {{[(?*1000)/1000]/1000}/1000}/8 gB
= [(?*1000)/1024]/8 KB
= {[(?*1000)/1024]/1024}/8 MB
= {{[(?*1000)/1024]/1024}/1024}/8 GB

? Kb | Kbits (Kilobitów | Kilobits) =
= ?*1024 b
= (?*1024)/1000 kb
= [(?*1024)/1000]/1000 mb
= {[(?*1024)/1000]/1000}/1000 gb
= [(?*1024)/1024]/1024 Mb
= {[(?*1024)/1024]/1024}/1024 Gb
= (?*1024)/8 B
= [(?*1024)/1000]/8 kB
= {[(?*1024)/1000]/1000}/8 mB
= {{[(?*1024)/1000]/1000}/1000}/8 gB
= [(?*1024)/1024]/8 KB
= {[(?*1024)/1024]/1024}/8 MB
= {{[(?*1024)/1024]/1024}/1024}/8 GB

? B | bytes (bajtów | bytes) =
= ?*8 b
= (?/1000)*8 kb
= [(?/1000)/10000]*8 mb
= {[(?/1000)/1000]/1000}*8 gb
= (?/1024)*8 Kb
= [(?/1024)/1024]*8 Mb
= {[(?/1024)/1024]/1024}*8 Gb
= ?/1000 kB
= (?/1000)/1000 mB
= [(?/1000)/1000]/1000 gB
= ?/1024 KB
= (?/1024)/1024 MB
= [(?/1024)/1024]/1024 GB

? kB | kBytes (kilobajtów | kilobytes) =
= (?*1000)*8 b
= [(?*1000)/1000]*8 kb
= {[(?*1000)/1000]/10000}*8 mb
= {{[(?*1000)/1000]/1000}/1000}*8 gb
= [(?*1000)/1024]*8 Kb
= {[(?*1000)/1024]/1024}*8 Mb
= {{[(?*1000)/1024]/1024}/1024}*8 Gb
= ?*1000 B
= [(?*1000)/1000]/1000 mB
= {[(?*1000)/1000]/1000}/1000 gB
= (?*1000)/1024 KB
= [(?*1000)/1024]/1024 MB
= {[(?*1000)/1024]/1024}/1024 GB

? KB | KBytes (Kilobajtów | Kilobytes) =
= (?*1024)*8 b
= [(?*1024)/1000]*8 kb
= {[(?*1024)/1000]/1000}*8 mb
= {{[(?*1024)/1000]/1000}/1000}*8 gb
= [(?*1024)/1024]*8 Kb
= {[(?*1024)/1024]/1024}*8 Mb
= {{[(?*1024)/1024]/1024}/1024}*8 Gb
= ?*1024 B
= (?*1024)/1000 kB
= [(?*1024)/1000]/1000 mB
= {[(?*1024)/1000]/1000}/1000 gB
= [(?*1024)/1024]/1024 MB
= {[(?*1024)/1024]/1024}/1024 GB

? mb | mbits (megabitów | megabits) =
= ?*1000*1000 b
= (?*1000*1000)/1000 kb
= {[(?*1000*1000)/1000]/1000}/1000 gb
= (?*1000*1000)/1024 Kb
= [(?*1000*1000)/1024]/1024 Mb
= {[(?*1000*1000)/1024]/1024}/1024 Gb
= (?*1000*1000)/8 B
= [(?*1000*1000)/1000]/8 kB
= {[(?*1000*1000)/1000]/1000}/8 mB
= {{[(?*1000*1000)/1000]/1000}/1000}/8 gB
= [(?*1000*1000)/1024]/8 KB
= {[(?*1000*1000)/1024]/1024}/8 MB
= {{[(?*1000*1000)/1024]/1024}/1024}/8 GB

? Mb | Mbits (Megabitów | Megabits) =
= ?*1024*1024 b
= (?*1024*1024)/1000 kb
= [(?*1024*1024)/1000]/1000 mb
= {[(?*1024*1024)/1000]/1000}/1000 gb
= (?*1024*1024)/1024 Kb
= {[(?*1024*1024)/1024]/1024}/1024 Gb
= (?*1024*1024)/8 B
= [(?*1024*1024)/1000]/8 kB
= {[(?*1024*1024)/1000]/1000}/8 mB
= {{[(?*1024*1024)/1000]/1000}/1000}/8 gB
= [(?*1024*1024)/1024]/8 KB
= {[(?*1024*1024)/1024]/1024}/8 MB
= {{[(?*1024*1024)/1024]/1024}/1024}/8 GB

? mB | mBytes (megabajtów | megabytes) =
= (?*1000*1000)*8 b
= [(?*1000*1000)/1000]*8 kb
= (?*1000*1000)/1000/1000*8 mb
= {{[(?*1000*1000)/1000]/1000}/1000}*8 gb
= [(?*1000*1000)/1024]*8 Kb
= {[(?*1000*1000)/1024]/1024}*8 Mb
= {{[(?*1000*1000)/1024]/1024}/1024}*8 Gb
= ?*1000*1000 B
= [(?*1000*1000)/1000] kB
= {[(?*1000*1000)/1000]/1000}/1000 gB
= [(?*1000*1000)/1024]*8 KB
= [(?*1000*1000)/1024]/1024 MB
= {[(?*1000*1000)/1024]/1024}/1024 GB

? MB | MBytes (Megabajtów | Megabytes) =
= (?*1024*1024)*8 b
= [(?*1024*1024)/1000]*8 kb
= {[(?*1024*1024)/1000]/1000}*8 mb
= {{[(?*1024*1024)/1000]/1000}/1000}*8 gb
= [(?*1024*1024)/1024]*8 Kb
= {[(?*1024*1024)/1024]/1024}*8 Mb
= {{[(?*1024*1024)/1024]/1024}/1024}*8 Gb
= ?*1024*1024 B
= (?*1024*1024)/1000 kB
= [(?*1024*1024)/1000]/1000 mB
= {[(?*1024*1024)/1000]/1000}/1000 gB
= (?*1024*1024)/1024 KB
= {[(?*1024*1024)/1024]/1024}/1024 GB

? gb | gbits (gigabitów | gigabits) =
= ?*1000*1000*1000 b
= (?*1000*1000*1000)/1000 kb
= [(?*1000*1000*1000)/1000]/1000 mb
= (?*1000*1000*1000)/1024 Kb
= [(?*1000*1000*1000)/1024]/1024 Mb
= {[(?*1000*1000*1000)/1024]/1024}/1024 Gb
= (?*1000*1000*1000)/8 B
= [(?*1000*1000*1000)/1000]/8 kB
= {{[(?*1000*1000*1000)/1000]/1000}/8 mB
= {{[(?*1000*1000*1000)/1000]/1000}/1000}/8 gB
= [(?*1000*1000*1000)/1024]/8 KB
= {[(?*1000*1000*1000)/1024]/1024}/8 MB
= {{[(?*1000*1000*1000)/1024]/1024}/1024}/8 GB

? Gb | Gbits (Gigabitów | Gigabits) =
= ?*1024*1024*1024 b
= (?*1024*1024*1024)/1000 kb
= [(?*1024*1024*1024)/1000]/1000 mb
= {[(?*1024*1024*1024)/1000]/1000}/1000 gb
= (?*1024*1024*1024)/1024 Kb
= [(?*1024*1024*1024)/1024]/1024 Mb
= (?*1024*1024*1024)/8 B
= [(?*1024*1024*1024)/1000]/8 kB
= {[(?*1024*1024*1024)/1000]/1000}/8 mB
= {{[(?*1024*1024*1024)/1000]/1000}/1000}/8 gB
= [(?*1024*1024*1024)/1024]/8 KB
= {[(?*1024*1024*1024)/1024]/1024}/8 MB
= {{[(?*1024*1024*1024)/1024]/1024}/1024}/8 GB

? gB | gBytes (gigabajtów | gigabytes) =
= (?*1000*1000*1000)*8 b
= [(?*1000*1000*1000)/1000]*8 kb
= (?*1000*1000*1000)/1000/1000*8 mb
= {{[(?*1000*1000*1000)/1000]/1000}/1000}*8 gb
= [(?*1000*1000*1000)/1024]*8 Kb
= {[(?*1000*1000*1000)/1024]/1024}*8 Mb
= {{[(?*1000*1000*1000)/1024]/1024}/1024}*8 Gb
= ?*1000*1000*1000 B
= [(?*1000*1000*1000)/1000] kB
= [(?*1000*1000*1000)/1000]/1000 mB
= (?*1000*1000*1000)/1024 KB
= [(?*1000*1000*1000)/1024]/1024 MB
= {[(?*1000*1000*1000)/1024]/1024}/1024 GB

? GB | GBytes (Gigabajtów | Gigabytes) =
= (?*1024*1024*1024)*8 b
= [(?*1024*1024*1024)/1000]*8 kb
= {[(?*1024*1024*1024)/1000]/1000}*8 mb
= {{[(?*1024*1024*1024)/1000]/1000}/1000}*8 gb
= [(?*1024*1024*1024)/1024]*8 Kb
= {[(?*1024*1024*1024)/1024]/1024}*8 Mb
= {{[(?*1024*1024*1024)/1024]/1024}/1024}*8 Gb
= ?*1024*1024*1024 B
= (?*1024*1024*1024)/1000 kB
= [(?*1024*1024*1024)/1000]/1000 mB
= {[(?*1024*1024*1024)/1000]/1000}/1000 gB
= (?*1024*1024*1024)/1024 KB
= [(?*1024*1024*1024)/1024]/1024 MB

Jeżeli chcemy przeliczyć z b na B, to wartość dzielimy przez 8.
Przykład.
Mamy prędkość łącza internetowego 512Kb. Ile jest to w KB?
512Kb / 8 = 64KB

Jeżeli chcemy przeliczyć z B na b, to wartość mnożymy przez 8.
Przykład.
Ściągamy pliki z prędkością 64KB, a chcemy poznać prędkość łącza, które jest podawane w bitach.
64KB * 8 = 512Kb

Ściągamy pliki z prędkością 128KB (np. na sekundę), a chcemy poznać szybkość transferu w Kilo bitach.
Rozwiązanie:
128KB * 8 = 1024Kb (np. na sekundę)

Jeżeli chcemy przeliczyć z K na M, to dzielimy przez 1024.
Przykład.
Przeliczyliśmy w powyższym przykładzie, że posiadamy łącze 1024Kb. Teraz chcemy podać tą wartość podać w Mb
1024Kb / 1024 = 1Mb

Jeżeli chcemy przeliczyć z M na K, to mnożymy przez 1024.
Przykład.
Mamy łącze internetowe o prędkości 4Mb (przyjmujemy, że taka jest wartość transferu przychodzącego). Nasz znajomy mówi, że ma 512Kb (też chodzi o górną granicę szybkości transferu przychodzącego). Aby w prosty sposób porównać te wielkości zamieniamy 4Mb na Kb
4Mb * 1024 = 4096Kb
Łącze 4Mb jest 8 razy szybsze od 512Kb (4096Kb/512Kb=8)
Oczywiście nie wchodzimy tutaj w szczegóły charakteru sieci np. dodatkowych limitów transferu przychodzącego i wychodzącego, ustalonego od widzimisie administratora danej sieci. Przykład ma nam jedynie pomóc zrozumieć technikę przeliczania jednostek.

Inny przykład: mamy prędkość sieci Fast Ethernet = 100 Mb/s (przychodzące). Chcemy sprawdzić, jak długo będzie się przegrywał film 700MB:
Wyliczenia:
100 Mb = 100 Mb / 8 = 12,5MB
czyli prędkość takiej sieci wynosi 12,5MB/s , a zatem 700MB film będzie się ściągał do nas przez 56sekund gdyż:
700MB / 12,5MBps = 56s
Oczywiście nie uwzględniamy tutaj zakłóceń pracy sieci, specyfiki łącza i podobnych dodatków.

* * *

Uwaga: z powodu namnożenia się różnych złodziejskich witryn, które kopiują moje strony i umieszczają je u siebie wraz z komercyjnymi reklamami (na których zarabiają) informuję, że wszelkie prawa są zastrzeżone.

Zainteresowanych witryną gorzow-wlkp.pl/linux zapraszam do pobrania spakowanej wersji w formacie RAR.

Witryna była dostępna pod adresami: strony.wp.pl/wp/twarogal , strony.wp.pl/wp/linuxtwarka , twarogal.republika.pl , klub.chip.pl/twarogal oraz gorzow-wlkp.net (w latach 2003/04).

Informacje o odwiedzających są rejestrowane i publicznie udostępniane na pod adresem: http://gorzow-wlkp.pl/licznik/