Duże liczby nie mnożą się poprawnie!

Question

Użyłem zmiennej typu long double, dodałem bibliotekę iomanip, wpisałem cout << setprecision(100); i program przy mnożeniu przez sto miliardów lub więcej ma problem bo wypisuje mi takie liczby

Answer 1

Zakres funkcji w C++ jest ograniczony https://gmplib.org/.

Albo zapomniałeś o dodaniu odpowiedniej dyrektywy przy liczbach do L LONG DOUBLA

Comments

o co chodzi z rozszerzeniem .lz ?

Answer 2

A mógłbyś mi powiedzieć jak mam tego użyć?? Pobrałem w formacie bz2 i jest tam kilka folderów i dużo plików z formatem C i kilka w innych formatach.

Answer 3

A nawet jeśli bym nie mógł tego pomnożyć to bym mógł dopisać do tych liczb zera których z każdą liczbą było by więcej o 1?

Answer 4

Niewyraźne to Twoje zdjęcie. :P Ale odpowiedź - zdaje mi się - jest prozaiczna. :)

Typ double jest typem zmiennoprzecinkowym, co - wbrew opinii niektórych - nie oznacza liczby rzeczywistej.

Żeby najtrafniej to ująć, po prostu przytoczę cytat z Wikipedii:

[przy pomocy liczby zmiennoprzecinkowej] reprezentacja liczby rzeczywistej jest tylko przybliżona, a jedna liczba zmiennoprzecinkowa może reprezentować różne liczby rzeczywiste z pewnego zakresu.

http://pl.wikipedia.org/wiki/Liczba_zmiennoprzecinkowa

W skrócie spowodowane jest to faktem, że taki typ stworzony jest do tego, żeby przechowywać albo bardzo małe, albo bardzo duże wartości, a im większe (mniejsze) one są, tym mniej dokładnie są przechowywane - bo niestety komputery mają ograniczoną zdolność przechowywania danych. :<

Comments

No zdjęć się nie da na tym forum lepszych wrzucić...

---

Spokojnie. :) A rozumiesz już, dlaczego dostajesz takie wyniki?

---

No nie za bardzo rozumiem, jakoś panu Mirosławowi działało dodawanie STRASZNIE DUŻYCH liczb fibonacciego, ale czemu mnożenie tak nie działa??

---

Jakbyś jeszcze podał kod, to można by było pogadać. ;) Nie wiem, jak wielkie liczby próbujesz mnożyć.

Dodawanie jest operacją inną, dużo mniej wrażliwą na błedy, niż mnożenie. Przy mnożeniu już niewielkie niedokładności dają duże zakłamania - dużo większe, niż przy dodawaniu.

Weźmy prosty przykład: pomnóż trzykrotnie przez siebie 10 oraz trzykrotnie 10.1.

10 x 10 x 10 = 1000
10.1 x 10.1 x 10.1 = 1030.3010

Przy różnicy jednej dziesiątej, po dwóch mnożeniach masz już rozbieżność wyniku na poziomie powyżej trzydziestu.

Przy dodawaniu nie ma tak drastycznej różnicy:
10 + 10 + 10 = 30
10.1 + 10.1 + 10.1 = 30.3

---

Hmm, jakoś to naprawiłem. Błąd był w tym, że zmienna przez którą mnożyłem była w int zamiast w long double :-)

Dla ciekawskich wklejam kod

// Ta aplikacja wyznaczy tajny kod według twojego imienia lub jakiegoś wyrazu :)
#include "stdafx.h"
#include <iostream>
#include <locale>
#include <cstdio>
#include <windows.h>
#include <cstdlib>
#include <conio.h>
#include <algorithm>
#include <iomanip>

using namespace std;

void changecol(int numofcol)
{
	HANDLE Kolor;
	Kolor = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(Kolor, numofcol);
}
//void changesize(int numofsize)
//{
//	HANDLE Wielkosc;
//	Wielkosc = GetStdHandle(STD_OUTPUT_HANDLE);
//	SetConsoleFontSize(Wielkosc, numofsize);
//}

int polecenie;

int main()
{
	SetConsoleTitleA("Kod Imienia Lub Wyrazu");

	setlocale(LC_ALL, "polish"); //Ustawienie polskich znaków

	cout << setprecision(100);

	for (;;)
	{
		system("cls");

		polecenie = 0;

		changecol(3);
		cout << "                Ten program wyznaczy tajny kod dla twojego imienia!" << endl;
		changecol(15);
		cout << "======================================MENU======================================";
		changecol(10);
		cout << "1. Start Programu" << endl;
		cout << "2. Zasada działania" << endl;
		cout << "3. Zamknij program" << endl;
		changecol(15);
		cout << "================================================================================";
		cout << "                         Wpisz numer polecenia: ";
		cin >> polecenie;
		
		if (polecenie == 1)
		{
			const int tabD = 27;
			char tab[tabD] = { ' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
				'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };

			changecol(10);
			system("cls");
			cout << "===========================Wpisz swoje imię lub wyraz===========================";

			string imie;
			cout << endl << endl << endl;

			cin.ignore();
			getline(cin, imie);

			int dlugosc = imie.length();

			transform(imie.begin(), imie.end(), imie.begin(), ::toupper);
			int i3;
			int i2;
			long double liczba[40];
			int razy;

			cout << endl << endl;

			for (razy = 0; razy < 40; razy++)
			{
				liczba[razy] = 50;
			}

			for (i2 = 0; i2 < dlugosc; i2++)
			{
				for (i3 = 0; i3 < tabD; i3++)
				{
					if (imie[i2] == tab[i3]) liczba[i2] = i3;
				}
			}
			for (int i6 = 0; i6 < dlugosc; i6++)
			{
				if (liczba[i6] == 50)
				{
					changecol(4);
					cout << "No, w konsoli trudno jest zamienić polskie znaki na zwykłe, więc lepiej wpisz" << endl << "bez polskich znaków" << endl << endl << "Niestety trzeba wyłączyć program, bo napotkał krytyczny błąd";
					cout << endl << endl << "Dane wyjściowe: "; changecol(4); cout << imie;
					Sleep(7000);
					exit(0);
				}
			}
			cout << "Wprowadzony wyraz: " << imie << endl << endl << "Naciśnij dowolny klawisz, aby obliczyć kod..." << endl;
			_getch();

			long double mnoznik = 0.1;

			for (int i7 = 0; i7 < dlugosc; i7++)
			{
				mnoznik = mnoznik * 10;
				liczba[i7] = liczba[i7] * mnoznik;
				cout << liczba[i7] << endl;
			}

			_getch();
		}
		else if (polecenie == 2)
		{
			cout << "Narazie ten program nie działa :(";
			_getch();
		}
		else if (polecenie == 3)
		{
			changecol(7);
			system("cls");
			cout << "Zamykanie...";
			Sleep(500);
			exit(0);
		}
		else if (cin.fail())
		{
			cout << "Ktoś tu chyba nie umie wpisać polecenia :(((";
			Sleep(2000);
			cin.clear();
			cin.sync();
			continue;
		}
		else
		{
			cout << "Ktoś tu chyba nie umie wpisać polecenia :(((";
			Sleep(2000);
		}
	}
	return(0);
}

 

---

Nieskończona pętla for jest brzydka. :< Bardziej elegancka jest while(true). :)
A skoro problem rozwiązałeś, to 'good for you'. :)