YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Sahi aur reliable CChapter 62 of 73

Floating-point calculations aur math functions

Precision, rounding, tolerance policies, math domains, special values aur observed formats ki limits samjhein.

5 min readDevelopingC17 baseline
Offline reading
Is chapter mein8 sections

Measured length mein fraction ho sakta hai, lekin finite object har real number exactly store nahi kar sakta. Floating-point calculations representable values aur rounding rules se work karti hain. Good numeric code pehle acceptable error decide karta hai.

1. Representable values sochein

Floating-point format apne rules ke under sign, significand aur exponent use karta hai. Exponent scale aur significand finite detail deta hai. Magnitude ke saath representable numbers ki spacing badalti hai. Useful digits aur largest supported magnitude different properties hain.

Binary format mein 0.1 jaisi decimal fraction ki repeating expansion hoti hai aur normally nearby representable value li jaati hai. Jaise one third ko finite decimal digits se likhna. C har implementation par float aur double ko IEEE binary32 aur binary64 require nahi karti.

2. Observe karein; universal output assume na karein

Complete C17 program
#include <float.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    double total = 0.1 + 0.2;
    if (printf("%.*g\n", DBL_DECIMAL_DIG, total) < 0) return EXIT_FAILURE;
    return EXIT_SUCCESS;
}

Complete C17 program implementation ke double precision macro se result print karta hai. Common binary implementations par everyday decimal 0.3 se zyada digits dikh sakti hain. Printed string ko us build aur library ka observation samjhein. Test sab C implementations ke liye ek exact string impose nahi karta.

<float.h> FLT_RADIX, DBL_DIG aur DBL_EPSILON jaise properties describe karta hai. DBL_EPSILON type model mein one ke just upar ka gap hai; har comparison ka universal tolerance nahi. Conversions, intermediate formats, rounding modes aur build options observations affect kar sakte hain.

3. Comparison policy problem se aati hai

Maan lijiye measurements zero se 100 tak hain aur 0.01 units tak difference acceptable hai. Yeh measurement ki unit mein absolute-tolerance policy hai. Helper subtraction se pehle domain ke bahar ki values reject karta hai, taaki difference bounded rahe. Policy useful hai kyunki application ne ise choose kiya.

Complete C17 program
#include <assert.h>
#include <math.h>

/* This application compares measurements in [0, 100]. */
static int close_measurements(double left, double right)
{
    if (!isfinite(left) || !isfinite(right)) return 0;
    if (left < 0.0 || left > 100.0 || right < 0.0 || right > 100.0) return 0;
    return fabs(left - right) <= 0.01;
}

int main(void)
{
    assert(close_measurements(2.0, 2.005));
    assert(!close_measurements(2.0, 2.02));
    assert(!close_measurements(-1.0, 2.0));
    assert(!close_measurements(101.0, 2.0));
    assert(close_measurements(0.0, 0.0));
    return 0;
}

Wide magnitudes ke liye relative-error component useful ho sakta hai; zero ke paas absolute rule bhi chahiye ho sakta hai. Ek tolerance har scientific, graphics ya financial task ke liye suitable nahi. Approximate equality necessarily transitive nahi hoti; ise sorting comparator ka equivalence rule casually na banayein.

4. Math functions ke domains aur errors hain

<math.h> sqrt, log aur sin jaise functions aur float aur long double variants deta hai. Mathematical aur application domains check karein. Real square root ke liye nonnegative input chahiye; measurement application nonfinite input bhi reject kar sakti hai. Division by zero ko infinity banane ka portable tareeka na sikhayein.

Domain, pole aur range errors ke specified reporting rules hain. math_errhandling se dekhein ki implementation errno, floating-point exception flags ya dono use karti hai. Aise call ka errno check karna ho toh pehle clear karke documented convention follow karein; stale value current failure prove nahi karti. Kuch toolchains ko -lm jaise link option chahiye.

5. Rounding useful detail affect kar sakti hai

Bahut badi value mein tiny value add karne par stored result unchanged reh sakta hai. Nearly equal approximations subtract karne se relative accuracy lose ho sakti hai. Addition order badalne se floating-point result badal sakta hai; real-number identities rounded operations mein sab exact nahi rehti. Better algorithm wider type se zyada useful ho sakta hai.

Implementation NaNs aur infinities support kare toh unki explicit policy chahiye. Usual IEC comparison rules mein NaN khud ke equal bhi nahi hota; ordered comparisons ordinary finite numbers jaise nahi hote. Supported math facilities se classify karein; numeric type ko measurement validation na samjhein.

Sochkar dekhein

Kya measured distances compare karne ka acceptance threshold automatically DBL_EPSILON hai?

Explanation padhein

Nahi. Woh double model mein one ke paas ki property hai. Measurement units, scale, uncertainty aur task requirements suitable policy decide karte hain.

Primary references aur aage padhne ke links

Aage badhne se pehle

  • Floating-point values ki range aur precision finite hain; rounding implementation rules follow karti hai.
  • Comparison tolerance application units, domain aur acceptable error se aati hai.
  • Math domains, special values aur error reporting ki explicit policies chahiye.
In ideas ko alag rakhein
DBL_EPSILON / Application tolerance
One ke just upar ka gap arbitrary measurements ka universal acceptance threshold nahi deta.
Apne words mein samjhaayein

Addition order se floating-point observation badle toh compiler wrong hona kyun prove nahi hota?

Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.

Apni understanding check karein

Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.

Kya portable code assume kar sakta hai ki har math error sirf errno se report hota hai?
Har choice ki explanation padhein
  1. Haan, exceptions aur math_errhandling kabhi matter nahi karte.

    Implementation ki advertised error-handling facilities matter karti hain.

  2. Haan, har finite result prove karta hai ki domain ya range issue nahi tha.

    Is general shortcut ke bajay relevant function aur error contract inspect karein.

  3. Nahi. math_errhandling aur relevant function ke result/error rules follow karein.

    ✓ Sahi reasoning. Applicable errno aur floating-point exception reporting implementation contract ke according handle karein.

C17

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 62 / 73

Is chapter mein

Floating-point calculations aur math functions

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping