十進精度計算機

精密な十進計算

Mode:

High Precision Math

Precise Decimal Calculator

First Number

Second Number

Operation

Decimal Places (0-15)

Auto-calculate on input change

Scientific notation

Show as fraction

Why does JavaScript have precision errors?

JavaScript stores numbers as 64-bit floating-point values (IEEE 754 standard), which can cause rounding errors in decimal arithmetic. This is not a bug—it's how computers represent numbers in binary.

The Problem

0.1 + 0.2 → 0.30000000000000004 ❌

0.3 - 0.1 → 0.19999999999999998 ❌

0.1 * 0.2 → 0.020000000000000004 ❌

The Solution

This calculator uses Decimal.js, a JavaScript library that performs arbitrary-precision decimal arithmetic. It avoids floating-point representation by working with decimal strings internally, ensuring accurate calculations for financial applications, scientific computing, and any scenario requiring exact decimal precision.

JavaScript Implementation Examples

❌ Native JavaScript (Incorrect)

// Price calculation gone wrong
const price = 0.1;
const quantity = 3;
const total = price * quantity;
console.log(total); // 0.30000000000000004

// Tax calculation error
const amount = 0.2;
const tax = 0.1;
const withTax = amount + tax;
console.log(withTax); // 0.30000000000000004

✅ Using Decimal.js (Correct)

import Decimal from 'decimal.js';

// Accurate price calculation
const price = new Decimal(0.1);
const quantity = new Decimal(3);
const total = price.times(quantity);
console.log(total.toString()); // "0.3"

// Accurate tax calculation
const amount = new Decimal(0.2);
const tax = new Decimal(0.1);
const withTax = amount.plus(tax);
console.log(withTax.toString()); // "0.3"

// Set precision for financial calculations
Decimal.set({ precision: 10, rounding: 4 });

// Chain operations
const result = new Decimal('19.99')
  .times('1.08')        // Add 8% tax
  .toDecimalPlaces(2);  // Round to 2 decimals
console.log(result.toString()); // "21.59"

🔧 Alternative: Manual Integer Math

// Convert to cents for calculations
function multiply(a, b, decimals = 2) {
  const multiplier = Math.pow(10, decimals);
  const intA = Math.round(a * multiplier);
  const intB = Math.round(b * multiplier);
  return (intA * intB) / (multiplier * multiplier);
}

const price = 0.1;
const quantity = 3;
console.log(multiply(price, quantity)); // 0.03

// Note: This approach is limited and error-prone
// For production use, prefer Decimal.js

Expression Mode 🚀

Expression Mode allows you to evaluate complex mathematical expressions with high precision. It uses expr-eval parser combined with Decimal.js for accurate results.

Example expressions:

0.1 + 0.2 → Evaluates to exactly 0.3

(23.456 + 45.23) * 2 - 10 → Complex calculation with parentheses

435345345.7456 + 345345.234 - (345345.234234 * 234234) * 9 → Large numbers

Key Features

Expression Mode: Evaluate full mathematical expressions with parentheses and multiple operations
Arbitrary precision: Calculate with up to 15 decimal places
Six operations: Addition, subtraction, multiplication, division, power, and modulus
Fraction conversion: See decimal results as fractions (e.g., 0.5 → 1/2)
Scientific notation: Toggle exponential format for very large or small numbers
Auto-calculate: Results update as you type (Simple Mode only)
History tracking: Review your last 5 calculations

Common Use Cases

💰 Financial Calculations

Currency conversions, tax calculations, interest rates

🔬 Scientific Computing

Measurements, chemical calculations, physics equations

📊 Data Analysis

Statistical calculations, percentage computations

🛒 E-commerce

Shopping cart totals, discounts, shipping costs