వృత్తం వ్యాసార్థం గణనకర్త మరియు గణన పద్ధతులు

వ్యాసం, వృత్తం పరిధి లేదా ప్రాంతాన్ని ఉపయోగించి వృత్తం యొక్క వ్యాసార్థాన్ని గణించండి. జ్యామితీ గణనలకు మరియు వృత్తం లక్షణాలను అర్థం చేసుకోవడానికి అనుకూలం.

వృత్తం వ్యాసం గణన యంత్రం

📚

డాక్యుమెంటేషన్

ವೃತ್ತದ ತ್ರಿಜ್ಯೆ ಗಣಕ

ಪರಿಚಯ

ತ್ರಿಜ್ಯೆ ವೃತ್ತದ ಅತ್ಯಂತ ಮೂಲಭೂತ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಇದು ವೃತ್ತದ ಕೇಂದ್ರದಿಂದ ಅದರ ವೃತ್ತದ ವ್ಯಾಸದ ಮೇಲೆ ಇರುವ ಯಾವುದೇ ಬಿಂದುಗೆ ಇರುವ ಅಂತರವಾಗಿದೆ. ಈ ಗಣಕವು ಮೂವರು ವಿಭಿನ್ನ ಇನ್ಪುಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ವೃತ್ತದ ತ್ರಿಜ್ಯೆ ನಿರ್ಧರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

  1. ವ್ಯಾಸ
  2. ವೃತ್ತದ ಗಾತ್ರ
  3. ಪ್ರದೇಶ

ಈ ಮೌಲ್ಯಗಳಲ್ಲಿ ಯಾವುದೇ ಒಂದು ನೀಡುವುದರಿಂದ, ನೀವು ವೃತ್ತದ ಜ್ಯಾಮಿತೀಯದಲ್ಲಿನ ಗಣಿತೀಯ ಸಂಬಂಧಗಳನ್ನು ಬಳಸಿಕೊಂಡು ತ್ರಿಜ್ಯೆ ಅನ್ನು ಲೆಕ್ಕಹಾಕಬಹುದು.

ಸೂತ್ರ

ತ್ರಿಜ್ಯೆ ಅನ್ನು ವ್ಯಾಸ, ವೃತ್ತದ ಗಾತ್ರ ಅಥವಾ ಪ್ರದೇಶದಿಂದ ಈ ಕೆಳಗಿನ ಸೂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಬಹುದು:

  1. ವ್ಯಾಸದಿಂದ (dd):

    r=d2r = \frac{d}{2}
  2. ವೃತ್ತದ ಗಾತ್ರದಿಂದ (CC):

    r=C2πr = \frac{C}{2\pi}
  3. ಪ್ರದೇಶದಿಂದ (AA):

    r=Aπr = \sqrt{\frac{A}{\pi}}

ಈ ಸೂತ್ರಗಳು ವೃತ್ತದ ಮೂಲಭೂತ ಗುಣಲಕ್ಷಣಗಳಿಂದ ಉಲ್ಲೇಖಿತವಾಗಿವೆ:

  • ವ್ಯಾಸ: ವ್ಯಾಸವು ತ್ರಿಜ್ಯೆಯ ಎರಡು ಪಟ್ಟು (d=2rd = 2r) ಆಗಿದೆ.
  • ವೃತ್ತದ ಗಾತ್ರ: ವೃತ್ತದ ಸುತ್ತಲೂ ಇರುವ ಅಂತರ (C=2πrC = 2\pi r).
  • ಪ್ರದೇಶ: ವೃತ್ತದ ಒಳಗೆ ಇರುವ ಪ್ರದೇಶ (A=πr2A = \pi r^2).

ಲೆಕ್ಕಹಾಕುವುದು

ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುವುದು

ವ್ಯಾಸವನ್ನು ನೀಡಿದಾಗ, ತ್ರಿಜ್ಯೆ ಅದನ್ನು ಅರ್ಧವಾಗಿ ಮಾತ್ರ:

r=d2r = \frac{d}{2}

ಉದಾಹರಣೆ:

ವ್ಯಾಸ 10 ಯೂನಿಟ್‌ಗಳಾಗಿದ್ದರೆ:

r=102=5 ಯೂನಿಟ್‌ಗಳುr = \frac{10}{2} = 5 \text{ ಯೂನಿಟ್‌ಗಳು}

ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುವುದು

ವೃತ್ತದ ಗಾತ್ರದ ಸೂತ್ರದಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:

C=2πrC = 2\pi r

rr ಅನ್ನು ಲೆಕ್ಕಹಾಕಲು:

r=C2πr = \frac{C}{2\pi}

ಉದಾಹರಣೆ:

ವೃತ್ತದ ಗಾತ್ರ 31.415931.4159 ಯೂನಿಟ್‌ಗಳಾಗಿದ್ದರೆ:

r=31.41592π31.41596.28325 ಯೂನಿಟ್‌ಗಳುr = \frac{31.4159}{2\pi} \approx \frac{31.4159}{6.2832} \approx 5 \text{ ಯೂನಿಟ್‌ಗಳು}

ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುವುದು

ಪ್ರದೇಶದ ಸೂತ್ರದಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:

A=πr2A = \pi r^2

rr ಅನ್ನು ಲೆಕ್ಕಹಾಕಲು:

r=Aπr = \sqrt{\frac{A}{\pi}}

ಉದಾಹರಣೆ:

ಪ್ರದೇಶ 78.539878.5398 ಚದರ ಯೂನಿಟ್‌ಗಳಾಗಿದ್ದರೆ:

r=78.5398π=78.53983.141625=5 ಯೂನಿಟ್‌ಗಳುr = \sqrt{\frac{78.5398}{\pi}} = \sqrt{\frac{78.5398}{3.1416}} \approx \sqrt{25} = 5 \text{ ಯೂನಿಟ್‌ಗಳು}

ತೀವ್ರ ಪ್ರಕರಣಗಳು ಮತ್ತು ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆ

  • ಶೂನ್ಯ ಅಥವಾ ಋಣಾತ್ಮಕ ಇನ್ಪುಟ್‌ಗಳು: ವೃತ್ತಕ್ಕೆ ಋಣಾತ್ಮಕ ಅಥವಾ ಶೂನ್ಯ ವ್ಯಾಸ, ವೃತ್ತದ ಗಾತ್ರ ಅಥವಾ ಪ್ರದೇಶ ಇರಲು ಸಾಧ್ಯವಿಲ್ಲ. ಈ ಮೌಲ್ಯಗಳಲ್ಲಿ ಯಾವುದೇ ಒಂದು ಶೂನ್ಯ ಅಥವಾ ಋಣಾತ್ಮಕವಾದರೆ, ತ್ರಿಜ್ಯೆ ಅಸ್ಪಷ್ಟವಾಗಿದೆ. ಇಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಗಣಕವು ದೋಷ ಸಂದೇಶವನ್ನು ತೋರಿಸುತ್ತದೆ.

  • ಅಂಕೀಯವಲ್ಲದ ಇನ್ಪುಟ್‌ಗಳು: ಗಣಕವು ಅಂಕೀಯ ಇನ್ಪುಟ್‌ಗಳನ್ನು ಅಗತ್ಯವಿದೆ. ಅಂಕೀಯವಲ್ಲದ ಮೌಲ್ಯಗಳು (ಉದಾಹರಣೆಗೆ, ಅಕ್ಷರಗಳು ಅಥವಾ ಸಂಕೇತಗಳು) ಅಮಾನ್ಯವಾಗಿವೆ.

ಶುದ್ಧತೆ ಮತ್ತು ಗುಣಾಂಕನ

ಈ ಗಣಕವು ಲೆಕ್ಕಹಾಕಲು ಡಬಲ್-ಶುದ್ಧತೆಯ ತ浮ದ ತಂತ್ರಜ್ಞಾನವನ್ನು ಬಳಸುತ್ತದೆ. ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಾಲ್ಕು ದಶಮಾಂಶ ಸ್ಥಳಗಳಿಗೆ ಗುಣಾಂಕಿಸಲಾಗುತ್ತದೆ. π\pi ಎಂಬ ಗಣಿತೀಯ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಬಳಸುವಾಗ, ಗಣಕವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಅಥವಾ ಪರಿಸರದಲ್ಲಿ ಲಭ್ಯವಿರುವ ಸಂಪೂರ್ಣ ಶುದ್ಧತೆಯನ್ನು ಬಳಸುತ್ತದೆ. ತ浮ದ ಲೆಕ್ಕಹಾಕುವಿಕೆಗೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಣ್ಣ ಗುಣಾಂಕ ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸಬಹುದು.

ಬಳಕೆದಾರಿಕೆ

ವೃತ್ತದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುವುದು ವಿವಿಧ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ:

ಇಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು ನಿರ್ಮಾಣ

  • ವೃತ್ತಾಕಾರ ಘಟಕಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು: ಇಂಜಿನಿಯರ್‌ಗಳು ಚಕ್ರಗಳು, ಗಿಯರ್‌ಗಳು, ಪೈಪ್ಸ್ ಅಥವಾ ಗುಂಡಿಗಳು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ತ್ರಿಜ್ಯೆ ನಿರ್ಧರಿಸಲು ಅಗತ್ಯವಿದೆ.

  • ವಾಸ್ತುಶಿಲ್ಪ: ವಾಸ್ತುಶಿಲ್ಪಿಗಳು ಆರ್ಕ್‌ಗಳು, ಗುಂಡಿಗಳು ಮತ್ತು ವೃತ್ತಾಕಾರ ಕಟ್ಟಡಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ತ್ರಿಜ್ಯೆ ಬಳಸುತ್ತಾರೆ.

ಜ್ಯೋತಿಷ್ಯ

  • ಗ್ರಹಗಳ ಕಕ್ಷೆಗಳು: ಜ್ಯೋತಿಷ್ಯಿಗಳು ವೀಕ್ಷಣಾ ಡೇಟಾವನ್ನು ಆಧರಿಸಿ ಗ್ರಹಗಳ ಕಕ್ಷೆಯ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುತ್ತಾರೆ.

  • ಆಕಾಶೀಯ ದೇಹಗಳು: ಗ್ರಹಗಳು, ತಾರೆಗಳು ಮತ್ತು ಇತರ ಆಕಾಶೀಯ ವಸ್ತುಗಳ ಗಾತ್ರವನ್ನು ನಿರ್ಧರಿಸುವುದು.

ದಿನನಿತ್ಯದ ಸಮಸ್ಯೆ ಪರಿಹಾರ

  • ಕಲೆ ಮತ್ತು ವಿನ್ಯಾಸ: ಕಲಾವಿದರು ಮತ್ತು ವಿನ್ಯಾಸಕಾರರು ವೃತ್ತಾಕಾರ ಮಾದರಿಗಳು ಮತ್ತು ವಿನ್ಯಾಸಗಳನ್ನು ರಚಿಸಲು ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುತ್ತಾರೆ.

  • DIY ಯೋಜನೆಗಳು: ವೃತ್ತಾಕಾರ ಮೆಜಲು, ತೋಟಗಳು ಅಥವಾ ತೊಟ್ಟಿಗಳಿಗಾಗಿ ಅಗತ್ಯವಿರುವ ಸಾಮಾನುಗಳನ್ನು ಲೆಕ್ಕಹಾಕುವುದು.

ಗಣಿತ ಮತ್ತು ಶಿಕ್ಷಣ

  • ಜ್ಯಾಮಿತಿಯ ಅಧ್ಯಯನ: ವೃತ್ತಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಜ್ಯಾಮಿತಿಯ ಶಿಕ್ಷಣದಲ್ಲಿ ಮೂಲಭೂತವಾಗಿದೆ.

  • ಸಮಸ್ಯೆ ಪರಿಹಾರ: ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕುವಿಕೆ ಗಣಿತೀಯ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಮತ್ತು ಸ್ಪರ್ಧೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿದೆ.

ಪರ್ಯಾಯಗಳು

ತ್ರಿಜ್ಯೆ ಮುಖ್ಯ ಗುಣಲಕ್ಷಣವಾಗಿದ್ದರೂ, ಕೆಲವೊಮ್ಮೆ ಇತರ ವೃತ್ತದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನೇರವಾಗಿ ಅಳೆಯುವುದು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ:

  • ಚೋರ್ಡ್ ಉದ್ದವನ್ನು ಅಳೆಯುವುದು: ನೀವು ವೃತ್ತದಲ್ಲಿ ನಿರ್ಧಾರಿತ ಬಿಂದುಗಳನ್ನು ಹೊಂದಿದ್ದಾಗ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಲು ಉಪಯುಕ್ತವಾಗಿದೆ.

  • ಭಾಗೀಯ ಪ್ರದೇಶ ಅಥವಾ ವೃತ್ತದ ಉದ್ದವನ್ನು ಬಳಸುವುದು: ವೃತ್ತದ ಭಾಗಶಃ ವಿಭಾಗಗಳನ್ನು ಒಳಗೊಂಡ ಸಂದರ್ಭಗಳಲ್ಲಿ.

ಇತಿಹಾಸ

ವೃತ್ತಗಳ ಅಧ್ಯಯನವು ಪ್ರಾಚೀನ ನಾಗರಿಕತೆಗಳಿಗೆ ಹಿಂತಿರುಗುತ್ತದೆ:

  • ಪ್ರಾಚೀನ ಜ್ಯಾಮಿತಿ: ಪ್ರಾಚೀನ ಈಜಿಪ್ಟಿಯ ಮತ್ತು ಬಾಬಿಲೋನಿಯ ಕಾಲದಿಂದ ವೃತ್ತವನ್ನು ಅಧ್ಯಯನ ಮಾಡಲಾಗಿದೆ.

  • ಯೂಕ್ಲಿಡ್‌ನ ಮೂಲಗಳು: ಕ್ರಿ.ಪೂ. 300 ರಲ್ಲಿ, ಯೂಕ್ಲಿಡ್ ತನ್ನ ಪ್ರಮುಖ ಕೃತಿಯಲ್ಲಿ, ಮೂಲಗಳು, ವೃತ್ತ ಮತ್ತು ಅದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರು.

  • ಆರ್ಕಿಮಿಡೀಸ್: (\pi) ಅನ್ನು ಅಂದಾಜಿಸಲು ವಿಧಾನಗಳನ್ನು ಒದಗಿಸಿದರು ಮತ್ತು ವೃತ್ತಗಳು ಮತ್ತು ಗೋಲಕಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರದೇಶಗಳು ಮತ್ತು ಪ್ರಮಾಣಗಳನ್ನು ಲೆಕ್ಕಹಾಕಿದರು.

  • (\pi) ಯ ಅಭಿವೃದ್ಧಿ: ಶತಮಾನಗಳಿಂದ, ಲಿಯು ಹೂಯಿ, ಜು ಚಾಂಗ್ಜಿ, ಆರ್ಯಭಟ, ಮತ್ತು ಕೊನೆಗೆ ಜಾನ್ ವಾಲಿಸ್ ಮತ್ತು ಐಜಾಕ್ ನ್ಯೂಟನ್ (\pi) ಯ ಮೌಲ್ಯ ಮತ್ತು ಅರ್ಥವನ್ನು ಪರಿಷ್ಕೃತಗೊಳಿಸಿದರು.

ತ್ರಿಜ್ಯೆ ಮಾತ್ರವಲ್ಲದೆ, ಜ್ಯಾಮಿತಿಯಲ್ಲಿಯೇ ಮಾತ್ರವಲ್ಲದೆ, ಭೌತಶಾಸ್ತ್ರ, ಇಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು ವಿವಿಧ ಅನ್ವಯಿತ ವಿಜ್ಞಾನಗಳಲ್ಲಿ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.

ಉದಾಹರಣೆಗಳು

ವ್ಯಾಸ, ವೃತ್ತದ ಗಾತ್ರ ಮತ್ತು ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಲು ಹಲವಾರು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆ.

ವ್ಯಾಸದಿಂದ

ಪೈಥಾನ್
1## ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2def radius_from_diameter(diameter):
3    if diameter <= 0:
4        raise ValueError("Diameter must be greater than zero.")
5    return diameter / 2
6
7## ಉದಾಹರಣೆ ಬಳಕೆ
8d = 10
9r = radius_from_diameter(d)
10print(f"The radius is {r} units.")
11
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
1// ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2function radiusFromDiameter(diameter) {
3    if (diameter <= 0) {
4        throw new Error("Diameter must be greater than zero.");
5    }
6    return diameter / 2;
7}
8
9// ಉದಾಹರಣೆ ಬಳಕೆ
10let d = 10;
11let r = radiusFromDiameter(d);
12console.log(`The radius is ${r} units.`);
13
ಜಾವಾ
1public class CircleRadiusCalculator {
2    public static double radiusFromDiameter(double diameter) {
3        if (diameter <= 0) {
4            throw new IllegalArgumentException("Diameter must be greater than zero.");
5        }
6        return diameter / 2;
7    }
8
9    public static void main(String[] args) {
10        double d = 10;
11        double r = radiusFromDiameter(d);
12        System.out.printf("The radius is %.2f units.%n", r);
13    }
14}
15
C++
1// ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2#include <iostream>
3#include <stdexcept>
4
5double radiusFromDiameter(double diameter) {
6    if (diameter <= 0) {
7        throw std::invalid_argument("Diameter must be greater than zero.");
8    }
9    return diameter / 2.0;
10}
11
12int main() {
13    double d = 10.0;
14    try {
15        double r = radiusFromDiameter(d);
16        std::cout << "The radius is " << r << " units." << std::endl;
17    } catch (const std::exception& e) {
18        std::cerr << e.what() << std::endl;
19    }
20    return 0;
21}
22
R
1## ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2radius_from_diameter <- function(diameter) {
3  if (diameter <= 0) {
4    stop("Diameter must be greater than zero.")
5  }
6  return(diameter / 2)
7}
8
9## ಉದಾಹರಣೆ ಬಳಕೆ
10d <- 10
11r <- radius_from_diameter(d)
12cat(sprintf("The radius is %.2f units.\n", r))
13
ರೂಬಿ
1## ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2def radius_from_diameter(diameter)
3  raise ArgumentError, "Diameter must be greater than zero." if diameter <= 0
4  diameter / 2.0
5end
6
7## ಉದಾಹರಣೆ ಬಳಕೆ
8d = 10
9r = radius_from_diameter(d)
10puts "The radius is #{r} units."
11
PHP
1<?php
2// ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
3function radiusFromDiameter($diameter) {
4    if ($diameter <= 0) {
5        throw new Exception('Diameter must be greater than zero.');
6    }
7    return $diameter / 2;
8}
9
10// ಉದಾಹರಣೆ ಬಳಕೆ
11$d = 10;
12$r = radiusFromDiameter($d);
13echo "The radius is {$r} units.";
14?>
15
ರಸ್ಟ್
1// ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
3    if diameter <= 0.0 {
4        return Err("Diameter must be greater than zero.");
5    }
6    Ok(diameter / 2.0)
7}
8
9fn main() {
10    let d = 10.0;
11    match radius_from_diameter(d) {
12        Ok(r) => println!("The radius is {:.2} units.", r),
13        Err(e) => println!("{}", e),
14    }
15}
16
ಸ್ವಿಫ್ಟ್
1import Foundation
2
3// ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4func radiusFromDiameter(_ diameter: Double) throws -> Double {
5    if diameter <= 0 {
6        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Diameter must be greater than zero."])
7    }
8    return diameter / 2.0
9}
10
11// ಉದಾಹರಣೆ ಬಳಕೆ
12do {
13    let d = 10.0
14    let r = try radiusFromDiameter(d)
15    print("The radius is \(r) units.")
16} catch {
17    print(error.localizedDescription)
18}
19

ವೃತ್ತದ ಗಾತ್ರದಿಂದ

ಪೈಥಾನ್
1import math
2
3## ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4def radius_from_circumference(circumference):
5    if circumference <= 0:
6        raise ValueError("Circumference must be greater than zero.")
7    return circumference / (2 * math.pi)
8
9## ಉದಾಹರಣೆ ಬಳಕೆ
10C = 31.4159
11r = radius_from_circumference(C)
12print(f"The radius is {r:.2f} units.")
13
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
1// ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2function radiusFromCircumference(circumference) {
3    if (circumference <= 0) {
4        throw new Error("Circumference must be greater than zero.");
5    }
6    return circumference / (2 * Math.PI);
7}
8
9// ಉದಾಹರಣೆ ಬಳಕೆ
10let C = 31.4159;
11let r = radiusFromCircumference(C);
12console.log(`The radius is ${r.toFixed(2)} units.`);
13
ಜಾವಾ
1public class CircleRadiusCalculator {
2    public static double radiusFromCircumference(double circumference) {
3        if (circumference <= 0) {
4            throw new IllegalArgumentException("Circumference must be greater than zero.");
5        }
6        return circumference / (2 * Math.PI);
7    }
8
9    public static void main(String[] args) {
10        double C = 31.4159;
11        double r = radiusFromCircumference(C);
12        System.out.printf("The radius is %.2f units.%n", r);
13    }
14}
15
C++
1// ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2#include <iostream>
3#include <cmath>
4#include <stdexcept>
5
6double radiusFromCircumference(double circumference) {
7    if (circumference <= 0) {
8        throw std::invalid_argument("Circumference must be greater than zero.");
9    }
10    return circumference / (2.0 * M_PI);
11}
12
13int main() {
14    double C = 31.4159;
15    try {
16        double r = radiusFromCircumference(C);
17        std::cout << "The radius is " << r << " units." << std::endl;
18    } catch (const std::exception& e) {
19        std::cerr << e.what() << std::endl;
20    }
21    return 0;
22}
23
R
1## ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2radius_from_circumference <- function(circumference) {
3  if (circumference <= 0) {
4    stop("Circumference must be greater than zero.")
5  }
6  return(circumference / (2 * pi))
7}
8
9## ಉದಾಹರಣೆ ಬಳಕೆ
10C <- 31.4159
11r <- radius_from_circumference(C)
12cat(sprintf("The radius is %.2f units.\n", r))
13
ರೂಬಿ
1## ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2def radius_from_circumference(circumference)
3  raise ArgumentError, "Circumference must be greater than zero." if circumference <= 0
4  circumference / (2 * Math::PI)
5end
6
7## ಉದಾಹರಣೆ ಬಳಕೆ
8C = 31.4159
9r = radius_from_circumference(C)
10puts "The radius is #{format('%.2f', r)} units."
11
PHP
1<?php
2// ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
3function radiusFromCircumference($circumference) {
4    if ($circumference <= 0) {
5        throw new Exception('Circumference must be greater than zero.');
6    }
7    return $circumference / (2 * M_PI);
8}
9
10// ಉದಾಹರಣೆ ಬಳಕೆ
11$C = 31.4159;
12$r = radiusFromCircumference($C);
13echo "The radius is " . round($r, 2) . " units.";
14?>
15
ರಸ್ಟ್
1use std::f64::consts::PI;
2
3// ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
5    if circumference <= 0.0 {
6        return Err("Circumference must be greater than zero.");
7    }
8    Ok(circumference / (2.0 * PI))
9}
10
11fn main() {
12    let C = 31.4159;
13    match radius_from_circumference(C) {
14        Ok(r) => println!("The radius is {:.2} units.", r),
15        Err(e) => println!("{}", e),
16    }
17}
18
ಸ್ವಿಫ್ಟ್
1import Foundation
2
3// ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4func radiusFromCircumference(_ circumference: Double) throws -> Double {
5    if circumference <= 0 {
6        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Circumference must be greater than zero."])
7    }
8    return circumference / (2 * Double.pi)
9}
10
11// ಉದಾಹರಣೆ ಬಳಕೆ
12do {
13    let C = 31.4159
14    let r = try radiusFromCircumference(C)
15    print(String(format: "The radius is %.2f units.", r))
16} catch {
17    print(error.localizedDescription)
18}
19

ಪ್ರದೇಶದಿಂದ

ಪೈಥಾನ್
1import math
2
3## ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4def radius_from_area(area):
5    if area <= 0:
6        raise ValueError("Area must be greater than zero.")
7    return math.sqrt(area / math.pi)
8
9## ಉದಾಹರಣೆ ಬಳಕೆ
10A = 78.5398
11r = radius_from_area(A)
12print(f"The radius is {r:.2f} units.")
13
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
1// ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2function radiusFromArea(area) {
3    if (area <= 0) {
4        throw new Error("Area must be greater than zero.");
5    }
6    return Math.sqrt(area / Math.PI);
7}
8
9// ಉದಾಹರಣೆ ಬಳಕೆ
10let A = 78.5398;
11let r = radiusFromArea(A);
12console.log(`The radius is ${r.toFixed(2)} units.`);
13
ಜಾವಾ
1public class CircleRadiusCalculator {
2    public static double radiusFromArea(double area) {
3        if (area <= 0) {
4            throw new IllegalArgumentException("Area must be greater than zero.");
5        }
6        return Math.sqrt(area / Math.PI);
7    }
8
9    public static void main(String[] args) {
10        double A = 78.5398;
11        double r = radiusFromArea(A);
12        System.out.printf("The radius is %.2f units.%n", r);
13    }
14}
15
C++
1// ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2#include <iostream>
3#include <cmath>
4#include <stdexcept>
5
6double radiusFromArea(double area) {
7    if (area <= 0) {
8        throw std::invalid_argument("Area must be greater than zero.");
9    }
10    return std::sqrt(area / M_PI);
11}
12
13int main() {
14    double A = 78.5398;
15    try {
16        double r = radiusFromArea(A);
17        std::cout << "The radius is " << r << " units." << std::endl;
18    } catch (const std::exception& e) {
19        std::cerr << e.what() << std::endl;
20    }
21    return 0;
22}
23
R
1## ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2radius_from_area <- function(area) {
3  if (area <= 0) {
4    stop("Area must be greater than zero.")
5  }
6  return(sqrt(area / pi))
7}
8
9## ಉದಾಹರಣೆ ಬಳಕೆ
10A <- 78.5398
11r <- radius_from_area(A)
12cat(sprintf("The radius is %.2f units.\n", r))
13
MATLAB
1% ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2function r = radius_from_area(area)
3    if area <= 0
4        error('Area must be greater than zero.');
5    end
6    r = sqrt(area / pi);
7end
8
9% ಉದಾಹರಣೆ ಬಳಕೆ
10A = 78.5398;
11r = radius_from_area(A);
12fprintf('The radius is %.2f units.\n', r);
13
C#
1using System;
2
3class CircleRadiusCalculator
4{
5    public static double RadiusFromArea(double area)
6    {
7        if (area <= 0)
8            throw new ArgumentException("Area must be greater than zero.");
9        return Math.Sqrt(area / Math.PI);
10    }
11
12    static void Main()
13    {
14        double A = 78.5398;
15        double r = RadiusFromArea(A);
16        Console.WriteLine("The radius is {0:F2} units.", r);
17    }
18}
19
Go
1package main
2
3import (
4	"fmt"
5	"math"
6)
7
8func radiusFromArea(area float64) (float64, error) {
9	if area <= 0 {
10		return 0, fmt.Errorf("Area must be greater than zero.")
11	}
12	return math.Sqrt(area / math.Pi), nil
13}
14
15func main() {
16	A := 78.5398
17	r, err := radiusFromArea(A)
18	if err != nil {
19		fmt.Println(err)
20		return
21	}
22	fmt.Printf("The radius is %.2f units.\n", r)
23}
24
ರೂಬಿ
1## ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2def radius_from_area(area)
3  raise ArgumentError, "Area must be greater than zero." if area <= 0
4  Math.sqrt(area / Math::PI)
5end
6
7## ಉದಾಹರಣೆ ಬಳಕೆ
8A = 78.5398
9r = radius_from_area(A)
10puts "The radius is #{format('%.2f', r)} units."
11
PHP
1<?php
2// ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
3function radiusFromArea($area) {
4    if ($area <= 0) {
5        throw new Exception('Area must be greater than zero.');
6    }
7    return sqrt($area / M_PI);
8}
9
10// ಉದಾಹರಣೆ ಬಳಕೆ
11$A = 78.5398;
12$r = radiusFromArea($A);
13echo "The radius is " . round($r, 2) . " units.";
14?>
15
ರಸ್ಟ್
1use std::f64::consts::PI;
2
3// ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4fn radius_from_area(area: f64) -> Result<f64, &'static str> {
5    if area <= 0.0 {
6        return Err("Area must be greater than zero.");
7    }
8    Ok((area / PI).sqrt())
9}
10
11fn main() {
12    let A = 78.5398;
13    match radius_from_area(A) {
14        Ok(r) => println!("The radius is {:.2} units.", r),
15        Err(e) => println!("{}", e),
16    }
17}
18
ಸ್ವಿಫ್ಟ್
1import Foundation
2
3// ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
4func radiusFromArea(_ area: Double) throws -> Double {
5    if area <= 0 {
6        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Area must be greater than zero."])
7    }
8    return sqrt(area / Double.pi)
9}
10
11// ಉದಾಹರಣೆ ಬಳಕೆ
12do {
13    let A = 78.5398
14    let r = try radiusFromArea(A)
15    print(String(format: "The radius is %.2f units.", r))
16} catch {
17    print(error.localizedDescription)
18}
19

ಎಕ್ಸೆಲ್

1## B1 ಸೆಲ್ಲಿನಲ್ಲಿ ವ್ಯಾಸದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
2=IF(B1>0, B1/2, "Invalid input")
3
4## B2 ಸೆಲ್ಲಿನಲ್ಲಿ ವೃತ್ತದ ಗಾತ್ರದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
5=IF(B2>0, B2/(2*PI()), "Invalid input")
6
7## B3 ಸೆಲ್ಲಿನಲ್ಲಿ ಪ್ರದೇಶದಿಂದ ತ್ರಿಜ್ಯೆ ಲೆಕ್ಕಹಾಕಿ
8=IF(B3>0, SQRT(B3/PI()), "Invalid input")
9

ದೃಶ್ಯೀಕರಣ

ತ್ರಿಜ್ಯೆ, ವ್ಯಾಸ ಮತ್ತು ವೃತ್ತದ ಗಾತ್ರದ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ವಿವರಿಸುವ SVG ಚಿತ್ರಣ:

ತ್ರಿಜ್ಯೆ (r) ವ್ಯಾಸ (d) ವೃತ್ತದ ಗಾತ್ರ (C)

ಉಲ್ಲೇಖಗಳು

  1. ವೃತ್ತ - ವಿಕಿಪೀಡಿಯಾ
  2. ವೃತ್ತದ ಗಾತ್ರ - ಮ್ಯಾಥ್ ಇಸ್ ಫನ್
  3. ವೃತ್ತದ ಪ್ರದೇಶ - ಖಾನ್ ಅಕಾಡೆಮಿ
  4. (\pi) ಯ ಇತಿಹಾಸ - ವಿಕಿಪೀಡಿಯಾ