വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കുന്ന കൽക്കുലേറ്റർ

പരിചയം

വൃത്തം ജ്യാമിതിയിലെ ഒരു അടിസ്ഥാന രൂപമാണ്, സമ്പൂർണതയും സമസ്യയും പ്രതിനിധാനം ചെയ്യുന്നു. നമ്മുടെ വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കുന്ന കൽക്കുലേറ്റർ ഒരു അറിയപ്പെടുന്ന പാരാമീറ്റർ അടിസ്ഥാനമാക്കി വൃത്തത്തിന്റെ അളവുകൾ, വ്യാസം, പരിസരം, കൂടാതെ പ്രദേശം കണക്കാക്കാൻ അനുവദിക്കുന്നു. ഈ ഉപകരണം വിദ്യാർത്ഥികൾ, എഞ്ചിനീയർമാർ, ശില്പശാലകൾ, കൂടാതെ വൃത്തങ്ങളുടെ ഗുണങ്ങളെ മനസ്സിലാക്കാൻ താൽപര്യമുള്ള ആരായെങ്കിലും അനിവാര്യമാണ്.

ഈ കൽക്കുലേറ്റർ എങ്ങനെ ഉപയോഗിക്കാം

1. നിങ്ങൾ അറിയുന്ന പാരാമീറ്റർ തിരഞ്ഞെടുക്കുക:

   • അർദ്ധവൃത്തം
   • വ്യാസം
   • പരിസരം
   • പ്രദേശം

2. വില നൽകുക:

   • തിരഞ്ഞെടുക്കപ്പെട്ട പാരാമീറ്ററിന് സംഖ്യാത്മകമായ മൂല്യം നൽകുക.
   • മൂല്യം പോസിറ്റീവ് റിയൽ നമ്പർ ആണെന്ന് ഉറപ്പാക്കുക.

3. കണക്കാക്കുക:

   • കൽക്കുലേറ്റർ ശേഷിക്കുന്ന വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കും.
   • പ്രദർശിപ്പിക്കുന്ന ഫലങ്ങൾ ഉൾപ്പെടുന്നു:
     • അർദ്ധവൃത്തം ($r$)
     • വ്യാസം ($d$)
     • പരിസരം ($C$)
     • പ്രദേശം ($A$)

ഇൻപുട്ട് സാധുത

ഉപയോക്തൃ ഇൻപുട്ടുകൾക്കായി കൽക്കുലേറ്റർ താഴെപ്പറയുന്ന പരിശോധനകൾ നടത്തുന്നു:

• പോസിറ്റീവ് നമ്പറുകൾ: എല്ലാ ഇൻപുട്ടുകളും പോസിറ്റീവ് റിയൽ നമ്പറുകൾ ആയിരിക്കണം.
• സാധുവായ സംഖ്യാത്മക മൂല്യങ്ങൾ: ഇൻപുട്ടുകൾ സംഖ്യാത്മകമായിരിക്കണം, മറ്റ് അക്ഷരങ്ങൾ അടങ്ങിയിരിക്കരുത്.

അസാധുവായ ഇൻപുട്ടുകൾ കണ്ടെത്തിയാൽ, ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കും, തിരുത്തുന്നതുവരെ കണക്കാക്കൽ മുന്നോട്ട് പോകുകയില്ല.

ഫോർമുലകൾ

അർദ്ധവൃത്തം, വ്യാസം, പരിസരം, കൂടാതെ വൃത്തത്തിന്റെ പ്രദേശം തമ്മിലുള്ള ബന്ധങ്ങൾ താഴെപ്പറയുന്ന ഫോർമുലകളാൽ നിർവചിക്കപ്പെടുന്നു:

1. വ്യാസം ($d$):

   $d = 2r$

2. പരിസരം ($C$):

   $C = 2\pi r = \pi d$

3. പ്രദേശം ($A$):

   $A = \pi r^2 = \frac{\pi d^2}{4}$

4. അർദ്ധവൃത്തം ($r$) പരിസരത്തിൽ നിന്ന്:

   $r = \frac{C}{2\pi}$

5. അർദ്ധവൃത്തം ($r$) പ്രദേശത്തിൽ നിന്ന്:

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

കണക്കാക്കൽ

ഉപയോക്താവിന്റെ ഇൻപുട്ട് അടിസ്ഥാനമാക്കി കൽക്കുലേറ്റർ ഓരോ അളവുകളും എങ്ങനെ കണക്കാക്കുന്നു:

1. അർദ്ധവൃത്തം ($r$) അറിയുമ്പോൾ:

   • വ്യാസം: $d = 2r$
   • പരിസരം: $C = 2\pi r$
   • പ്രദേശം: $A = \pi r^2$

2. വ്യാസം ($d$) അറിയുമ്പോൾ:

   • അർദ്ധവൃത്തം: $r = \frac{d}{2}$
   • പരിസരം: $C = \pi d$
   • പ്രദേശം: $A = \frac{\pi d^2}{4}$

3. പരിസരം ($C$) അറിയുമ്പോൾ:

   • അർദ്ധവൃത്തം: $r = \frac{C}{2\pi}$
   • വ്യാസം: $d = \frac{C}{\pi}$
   • പ്രദേശം: $A = \pi r^2$

4. പ്രദേശം ($A$) അറിയുമ്പോൾ:

   • അർദ്ധവൃത്തം: $r = \sqrt{\frac{A}{\pi}}$
   • വ്യാസം: $d = 2r$
   • പരിസരം: $C = 2\pi r$

എഡ്ജ് കേസുകൾ കൂടാതെ ഇൻപുട്ട് കൈകാര്യം ചെയ്യൽ

• നഗATIVE ഇൻപുട്ടുകൾ:

  • നെഗറ്റീവ് മൂല്യങ്ങൾ വൃത്തത്തിന്റെ അളവുകൾക്കായി സാധുവല്ല.
  • നെഗറ്റീവ് ഇൻപുട്ടുകൾക്ക് ഒരു പിശക് സന്ദേശം കൽക്കുലേറ്റർ പ്രദർശിപ്പിക്കും.

• സൂന്യമായ ഇൻപുട്ട്:

  • സൂന്യമായ ഒരു ഇൻപുട്ട് സാധുവായതാണ്, എന്നാൽ മറ്റ് എല്ലാ അളവുകളും സൂന്യമായിരിക്കുമെന്ന് ഫലിക്കുന്നു.
  • ശാരീരികമായി, സൂന്യമായ അളവുകൾ ഉള്ള ഒരു വൃത്തം നിലവിലില്ല, അതിനാൽ സൂന്യമായ ഒരു ഇൻപുട്ട് ഒരു സിദ്ധാന്തപരമായ കേസായി പ്രവർത്തിക്കുന്നു.

• അത്യന്തം വലിയ മൂല്യങ്ങൾ:

  • കൽക്കുലേറ്റർ വളരെ വലിയ സംഖ്യകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും, ഉപയോഗിക്കുന്ന പ്രോഗ്രാമിംഗ് ഭാഷയുടെ കൃത്യതയാൽ പരിമിതമായിരിക്കുന്നു.
  • അത്യന്തം വലിയ മൂല്യങ്ങളുമായി സാധ്യതയുള്ള റൗണ്ടിംഗ് പിശകുകൾക്കായി ശ്രദ്ധിക്കുക.

• അസംഖ്യാത്മക ഇൻപുട്ടുകൾ:

  • ഇൻപുട്ടുകൾ സംഖ്യാത്മകമായിരിക്കണം.
  • ഏതെങ്കിലും അസംഖ്യാത്മക ഇൻപുട്ട് ഒരു പിശക് സന്ദേശം നൽകും.

ഉപയോഗ കേസുകൾ

വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കുന്ന കൽക്കുലേറ്റർ വിവിധ യാഥാർത്ഥ്യ പ്രയോഗങ്ങളിൽ ഉപയോഗപ്രദമാണ്:

1. എഞ്ചിനീയറിംഗ്, ശില്പശാലകൾ:

   • പൈപ്പുകൾ, ചക്രങ്ങൾ, കൂടാതെ അർച്ചുകൾ പോലുള്ള വൃത്താകൃതിയിലുള്ള ഘടകങ്ങൾ രൂപകൽപ്പന ചെയ്യുന്നു.
   • വൃത്താകൃതികൾ ഉൾപ്പെടുന്ന നിർമ്മാണ പദ്ധതികൾക്കായി വസ്തുക്കളുടെ ആവശ്യകത കണക്കാക്കുന്നു.

2. ഉത്പാദനം:

   • ഭാഗങ്ങൾ, ഉപകരണങ്ങൾ എന്നിവയുടെ അളവുകൾ നിശ്ചയിക്കുന്നു.
   • CNC യന്ത്രങ്ങൾക്കായി കട്ടപ്പാതകൾ കണക്കാക്കുന്നു.

3. ജ്യോതിശാസ്ത്രം, ബഹിരാകാശ ശാസ്ത്രം:

   • സാധാരണയായി വൃത്തങ്ങൾ ആയി ഏകീകരിക്കപ്പെടുന്ന ഗ്രഹങ്ങളുടെ പാതകൾ കണക്കാക്കുന്നു.
   • ആകാശഗംഗകളുടെ ഉപരിതല പ്രദേശം കണക്കാക്കുന്നു.

4. ദിവസേന ജീവിതം:

   • വൃത്താകൃതിയിലുള്ള തോട്ടങ്ങൾ, കുളങ്ങൾ, അല്ലെങ്കിൽ വൃത്താകൃതിയിലുള്ള മേശകൾ രൂപകൽപ്പന ചെയ്യുന്നു.
   • വൃത്താകൃതിയിലുള്ള ചുറ്റുപാടുകൾക്കായി ആവശ്യമുള്ള കെട്ടുപണത്തിന്റെ അളവ് നിശ്ചയിക്കുന്നു.

പര്യായങ്ങൾ

വൃത്തങ്ങൾ അടിസ്ഥാനപരമായവയായിരുന്നാലും, വിവിധ പ്രയോഗങ്ങൾക്കായി പര്യായ രൂപങ്ങൾ, ഫോർമുലകൾ എന്നിവ ഉണ്ട്:

• എല്ലിപ്പ്സുകൾ:

  • നീളമുള്ള വൃത്തങ്ങൾ ആവശ്യമായ പ്രയോഗങ്ങൾക്കായി.
  • സെമിമേജർ, സെമിമിനോർ അക്ഷങ്ങൾ ഉൾപ്പെടുന്ന കണക്കുകൾ.

• സെക്ടറുകൾ, സെഗ്മെന്റുകൾ:

  • വൃത്തത്തിന്റെ ഒരു ഭാഗങ്ങൾ.
  • പൈ-ശൈലി കഷണങ്ങളുടെ പ്രദേശങ്ങൾ അല്ലെങ്കിൽ പരിസരങ്ങൾ കണക്കാക്കാൻ ഉപകാരപ്രദമാണ്.

• നിയമിത ബഹുജനങ്ങൾ:

  • വൃത്തങ്ങളെ സമാനമായ ആകൃതികളായ ഹെക്സഗോണുകൾ അല്ലെങ്കിൽ ഒക്ടഗോണുകൾ ഉപയോഗിച്ച് ഏകീകരിക്കുന്നു.
  • ചില എഞ്ചിനീയറിംഗ് സാഹചര്യങ്ങളിൽ കെട്ടുപണിയും കണക്കുകളും ലളിതമാക്കുന്നു.

ചരിത്രം

വൃത്തങ്ങളുടെ പഠനം പുരാതന സിവിലൈസേഷനുകളിലേക്ക് തിരിച്ചുപോകുന്നു:

• പുരാതന ഗണിതം:

  • ബാബിലോണിയക്കാർ, ഈജിപ്തക്കാർ $\pi$ ന്റെ ഏകീകരണങ്ങൾ ഉപയോഗിച്ചു.
  • ആർകിമിഡീസ് (ക. 287–212 BCE) $\pi$ കണക്കാക്കുന്നതിനുള്ള ആദ്യ രേഖപ്പെടുത്തിയ ആൽഗോരിതങ്ങൾ നൽകുന്നു, ഇത് $\frac{22}{7}$ മുതൽ $\frac{223}{71}$ വരെ ആകുന്നു.

• $\pi$ ന്റെ വികസനം:

  • വെയിൽഷ് ഗണിതശാസ്ത്രജ്ഞൻ വില്യം ജോൺസ് 1706 ൽ $\pi$ എന്ന ചിഹ്നം പ്രസിദ്ധീകരിച്ചു, പിന്നീട് ലിയോണഹാർഡ് യൂലർ സ്വീകരിച്ചു.
  • $\pi$ ഒരു അസംഖ്യാത്മക സംഖ്യയാണ്, ഇത് വൃത്തത്തിന്റെ പരിസരത്തിന്റെ വ്യാസത്തിലേക്കുള്ള അനുപാതം പ്രതിനിധാനം ചെയ്യുന്നു.

• ആധുനിക ഗണിതം:

  • വൃത്തം ത്രികോണം, കാൽക്കുലസ്, കൂടാതെ സമ്പൂർണ വിശകലനത്തിലെ വികസനങ്ങളിൽ കേന്ദ്രബിന്ദുവാണ്.
  • ഇത് ജ്യാമിതിയിലും ഗണിതപരമായ തെളിവുകളിലും ഒരു അടിസ്ഥാന ആശയമായി പ്രവർത്തിക്കുന്നു.

ഉദാഹരണങ്ങൾ

വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കുന്നതിനുള്ള വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ കണക്കാക്കുന്ന എങ്ങനെ എന്നതിനെക്കുറിച്ചുള്ള കോഡ് ഉദാഹരണങ്ങൾ താഴെ നൽകുന്നു:

## Python കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
import math

def calculate_circle_from_radius(radius):
    diameter = 2 * radius
    circumference = 2 * math.pi * radius
    area = math.pi * radius ** 2
    return diameter, circumference, area

## ഉദാഹരണ ഉപയോഗം:
radius = 5
d, c, a = calculate_circle_from_radius(radius)
print(f"അർദ്ധവൃത്തം: {radius}")
print(f"വ്യാസം: {d}")
print(f"പരിസരം: {c:.2f}")
print(f"പ്രദേശം: {a:.2f}")

// JavaScript കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
function calculateCircleFromDiameter(diameter) {
  const radius = diameter / 2;
  const circumference = Math.PI * diameter;
  const area = Math.PI * Math.pow(radius, 2);
  return { radius, circumference, area };
}

// ഉദാഹരണ ഉപയോഗം:
const diameter = 10;
const { radius, circumference, area } = calculateCircleFromDiameter(diameter);
console.log(`അർദ്ധവൃത്തം: ${radius}`);
console.log(`വ്യാസം: ${diameter}`);
console.log(`പരിസരം: ${circumference.toFixed(2)}`);
console.log(`പ്രദേശം: ${area.toFixed(2)}`);

// Java കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
public class CircleCalculator {
    public static void calculateCircleFromCircumference(double circumference) {
        double radius = circumference / (2 * Math.PI);
        double diameter = 2 * radius;
        double area = Math.PI * Math.pow(radius, 2);

        System.out.printf("അർദ്ധവൃത്തം: %.2f%n", radius);
        System.out.printf("വ്യാസം: %.2f%n", diameter);
        System.out.printf("പരിസരം: %.2f%n", circumference);
        System.out.printf("പ്രദേശം: %.2f%n", area);
    }

    public static void main(String[] args) {
        double circumference = 31.42;
        calculateCircleFromCircumference(circumference);
    }
}

// C# കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
using System;

class CircleCalculator
{
    static void CalculateCircleFromArea(double area)
    {
        double radius = Math.Sqrt(area / Math.PI);
        double diameter = 2 * radius;
        double circumference = 2 * Math.PI * radius;

        Console.WriteLine($"അർദ്ധവൃത്തം: {radius:F2}");
        Console.WriteLine($"വ്യാസം: {diameter:F2}");
        Console.WriteLine($"പരിസരം: {circumference:F2}");
        Console.WriteLine($"പ്രദേശം: {area:F2}");
    }

    static void Main()
    {
        double area = 78.54;
        CalculateCircleFromArea(area);
    }
}

## Ruby കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
def calculate_circle_from_radius(radius)
  diameter = 2 * radius
  circumference = 2 * Math::PI * radius
  area = Math::PI * radius ** 2
  return diameter, circumference, area
end

## ഉദാഹരണ ഉപയോഗം:
radius = 5.0
diameter, circumference, area = calculate_circle_from_radius(radius)
puts "അർദ്ധവൃത്തം: #{radius}"
puts "വ്യാസം: #{diameter}"
puts "പരിസരം: #{circumference.round(2)}"
puts "പ്രദേശം: #{area.round(2)}"

<?php
// PHP കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
function calculateCircleFromDiameter($diameter) {
    $radius = $diameter / 2;
    $circumference = pi() * $diameter;
    $area = pi() * pow($radius, 2);
    return array($radius, $circumference, $area);
}

// ഉദാഹരണ ഉപയോഗം:
$diameter = 10.0;
list($radius, $circumference, $area) = calculateCircleFromDiameter($diameter);
echo "അർദ്ധവൃത്തം: " . $radius . "\n";
echo "വ്യാസം: " . $diameter . "\n";
echo "പരിസരം: " . round($circumference, 2) . "\n";
echo "പ്രദേശം: " . round($area, 2) . "\n";
?>

// Rust കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
fn calculate_circle_from_circumference(circumference: f64) -> (f64, f64, f64) {
    let radius = circumference / (2.0 * std::f64::consts::PI);
    let diameter = 2.0 * radius;
    let area = std::f64::consts::PI * radius.powi(2);
    (radius, diameter, area)
}

fn main() {
    let circumference = 31.42;
    let (radius, diameter, area) = calculate_circle_from_circumference(circumference);
    println!("അർദ്ധവൃത്തം: {:.2}", radius);
    println!("വ്യാസം: {:.2}", diameter);
    println!("പരിസരം: {:.2}", circumference);
    println!("പ്രദേശം: {:.2}", area);
}

// Go കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
package main

import (
    "fmt"
    "math"
)

func calculateCircleFromArea(area float64) (radius, diameter, circumference float64) {
    radius = math.Sqrt(area / math.Pi)
    diameter = 2 * radius
    circumference = 2 * math.Pi * radius
    return
}

func main() {
    area := 78.54
    radius, diameter, circumference := calculateCircleFromArea(area)
    fmt.Printf("അർദ്ധവൃത്തം: %.2f\n", radius)
    fmt.Printf("വ്യാസം: %.2f\n", diameter)
    fmt.Printf("പരിസരം: %.2f\n", circumference)
    fmt.Printf("പ്രദേശം: %.2f\n", area)
}

// Swift കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
import Foundation

func calculateCircleFromRadius(radius: Double) -> (diameter: Double, circumference: Double, area: Double) {
    let diameter = 2 * radius
    let circumference = 2 * Double.pi * radius
    let area = Double.pi * pow(radius, 2)
    return (diameter, circumference, area)
}

// ഉദാഹരണ ഉപയോഗം:
let radius = 5.0
let results = calculateCircleFromRadius(radius: radius)
print("അർദ്ധവൃത്തം: \(radius)")
print("വ്യാസം: \(results.diameter)")
print("പരിസരം: \(String(format: "%.2f", results.circumference))")
print("പ്രദേശം: \(String(format: "%.2f", results.area))")

% MATLAB കോഡ് വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
function [radius, diameter, circumference, area] = calculateCircleFromRadius(radius)
    diameter = 2 * radius;
    circumference = 2 * pi * radius;
    area = pi * radius^2;
end

% ഉദാഹരണ ഉപയോഗം:
radius = 5;
[~, diameter, circumference, area] = calculateCircleFromRadius(radius);
fprintf('അർദ്ധവൃത്തം: %.2f\n', radius);
fprintf('വ്യാസം: %.2f\n', diameter);
fprintf('പരിസരം: %.2f\n', circumference);
fprintf('പ്രദേശം: %.2f\n', area);

' Excel ഫോർമുല വൃത്തത്തിന്റെ അളവുകൾ കണക്കാക്കാൻ
' അർദ്ധവൃത്തം A1 സെല്ലിൽ ആണെങ്കിൽ
വ്യാസം: =2*A1
പരിസരം: =2*PI()*A1
പ്രദേശം: =PI()*A1^2

സംഖ്യാത്മക ഉദാഹരണങ്ങൾ

1. അർദ്ധവൃത്തം (( r = 5 ) യൂണിറ്റ്) നൽകിയാൽ:

   • വ്യാസം: ( d = 2 \times 5 = 10 ) യൂണിറ്റ്
   • പരിസരം: ( C = 2\pi \times 5 \approx 31.42 ) യൂണിറ്റ്
   • പ്രദേശം: ( A = \pi \times 5^2 \approx 78.54 ) ചതുരശ്ര യൂണിറ്റ്

2. വ്യാസം (( d = 10 ) യൂണിറ്റ്) നൽകിയാൽ:

   • അർദ്ധവൃത്തം: ( r = \frac{10}{2} = 5 ) യൂണിറ്റ്
   • പരിസരം: ( C = \pi \times 10 \approx 31.42 ) യൂണിറ്റ്
   • പ്രദേശം: ( A = \frac{\pi \times 10^2}{4} \approx 78.54 ) ചതുരശ്ര യൂണിറ്റ്

3. പരിസരം (( C = 31.42 ) യൂണിറ്റ്) നൽകിയാൽ:

   • അർദ്ധവൃത്തം: ( r = \frac{31.42}{2\pi} \approx 5 ) യൂണിറ്റ്
   • വ്യാസം: ( d = 2 \times 5 = 10 ) യൂണിറ്റ്
   • പ്രദേശം: ( A = \pi \times 5^2 \approx 78.54 ) ചതുരശ്ര യൂണിറ്റ്

4. പ്രദേശം (( A = 78.54 ) ചതുരശ്ര യൂണിറ്റ്) നൽകിയാൽ:

   • അർദ്ധവൃത്തം: ( r = \sqrt{\frac{78.54}{\pi}} \approx 5 ) യൂണിറ്റ്
   • വ്യാസം: ( d = 2 \times 5 = 10 ) യൂണിറ്റ്
   • പരിസരം: ( C = 2\pi \times 5 \approx 31.42 ) യൂണിറ്റ്

ചിത്രങ്ങൾ

വൃത്തത്തിന്റെ അളവുകൾ, അർദ്ധവൃത്തം (( r )), വ്യാസം (( d )), പരിസരം (( C )), കൂടാതെ പ്രദേശം (( A )) എന്നിവയെ പ്രതിനിധീകരിക്കുന്ന ഒരു ചിത്രമാണ് താഴെ:

ചിത്രം: അർദ്ധവൃത്തം (( r )), വ്യാസം (( d )), പരിസരം (( C )), കൂടാതെ പ്രദേശം (( A )) എന്നിവയെ പ്രതിനിധീകരിക്കുന്ന വൃത്തത്തിന്റെ ചിത്രം.

റഫറൻസുകൾ

1. "Circle." Wolfram MathWorld, https://mathworld.wolfram.com/Circle.html.
2. "Circumference and Area of a Circle." Khan Academy, https://www.khanacademy.org/math/basic-geo/basic-geo-circles.
3. ബെക്ക്മാൻ, പെട്ര്. A History of ( \pi ). St. Martin's Press, 1971.
4. ആർകിമിഡീസ്. Measurement of a Circle, https://www.math.ubc.ca/~vjungic/students/Archimedes-Measurement%20of%20a%20Circle.pdf.