Apskritimo spindulio skaičiuoklė: skaičiuokite lengvai

Apskritimo spindulio skaičiuoklė

Įvadas

Apskritimo spindulys yra viena iš pagrindinių jo savybių. Tai atstumas nuo apskritimo centro iki bet kurios jo kraštinės taško. Ši skaičiuoklė leidžia nustatyti apskritimo spindulį remiantis trimis skirtingais įvesties parametrais:

Diametras
Apskritimo ilgis
Plotas

Pateikdami bet kurią iš šių reikšmių, galite apskaičiuoti spindulį, naudodami matematikos santykius, būdingus apskritimo geometrijai.

Formulė

Spindulys gali būti apskaičiuotas iš diametro, apskritimo ilgio arba ploto, naudojant šias formules:

Iš diametro ( $d$ ):
$r = \frac{d}{2}$
Iš apskritimo ilgio ( $C$ ):
$r = \frac{C}{2\pi}$
Iš ploto ( $A$ ):
$r = \sqrt{\frac{A}{\pi}}$

Šios formulės yra gautos iš pagrindinių apskritimo savybių:

Diametras: diametras yra dvigubai didesnis už spindulį ( $d = 2r$ ).
Apskritimo ilgis: apskritimo ilgis yra atstumas aplink apskritimą ( $C = 2\pi r$ ).
Plotas: apskritimo uždaro ploto ( $A = \pi r^2$ ).

Apskaičiavimas

Spindulio skaičiavimas iš diametro

Pateikus diametrą, spindulys yra tiesiog pusė jo:

r = \frac{d}{2}

Pavyzdys:

Jei diametras yra 10 vienetų:

r = \frac{10}{2} = 5 \text{ vienetai}

Spindulio skaičiavimas iš apskritimo ilgio

Pradedant nuo apskritimo ilgio formulės:

C = 2\pi r

Sprendžiant $r$ :

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

Pavyzdys:

Jei apskritimo ilgis yra $31.4159$ vienetų:

r = \frac{31.4159}{2\pi} \approx \frac{31.4159}{6.2832} \approx 5 \text{ vienetai}

Spindulio skaičiavimas iš ploto

Pradedant nuo ploto formulės:

A = \pi r^2

Sprendžiant $r$ :

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

Pavyzdys:

Jei plotas yra $78.5398$ kvadratiniai vienetai:

r = \sqrt{\frac{78.5398}{\pi}} = \sqrt{\frac{78.5398}{3.1416}} \approx \sqrt{25} = 5 \text{ vienetai}

Kraštutiniai atvejai ir įvesties validacija

Nuliniai arba neigiami įvestys: Apskritimas negali turėti neigiamo ar nulio diametro, apskritimo ilgio ar ploto. Jei bet kuri iš šių reikšmių yra nulis arba neigiama, spindulys yra neapibrėžtas. Skaičiuoklė tokiu atveju parodys klaidos pranešimą.
Nenumatyti įvestys: Skaičiuoklė reikalauja skaitinių įvesties. Neskaitinės reikšmės (pvz., raidės ar simboliai) yra neteisingos.

Tikslumas ir suapvalinimas

Ši skaičiuoklė naudoja dvigubo tikslumo plūduriuojančią kablelinę aritmetiką skaičiavimams. Rezultatai paprastai pateikiami suapvalinti iki keturių dešimtųjų, siekiant didesnio tikslumo. Naudojant matematikos konstantas, tokias kaip $\pi$ , skaičiuoklė naudoja visą tikslumą, kuris yra prieinamas programavimo kalboje ar aplinkoje. Būkite atsargūs, kad plūduriuojančios kablelinės aritmetikos gali sukelti mažų suapvalinimo klaidų kai kuriais atvejais.

Naudojimo atvejai

Apskritimo spindulio skaičiavimas yra svarbus įvairiose srityse:

Inžinerija ir statyba

Apskritinių komponentų projektavimas: Inžinieriai dažnai turi nustatyti spindulį, kai projektuoja ratus, pavaras, vamzdžius ar kupolus.
Architektūra: Architektai naudoja spindulį projektuodami arkas, kupolus ir apvalius pastatus.

Astronomija

Planetų orbitos: Astronomai skaičiuoja planetų orbitų spindulį remdamiesi stebėjimų duomenimis.
Dangaus kūnai: Nustatant planetų, žvaigždžių ir kitų dangaus objektų dydžius.

Kasdieniai problemų sprendimai

Menai ir dizainas: Menininkai ir dizaineriai skaičiuoja spindulį, kad sukurtų apvalius raštus ir dizainus.
DIY projektai: Apskaičiuojant medžiagas, reikalingas apvaliems stalams, sodams ar fontanams.

Matematika ir švietimas

Geometrijos mokymasis: Apskritimo savybių supratimas yra esminis geometrijos švietime.
Problemos sprendimas: Spindulio skaičiavimai yra dažni matematikos užduotyse ir varžybose.

Alternatyvos

Nors spindulys yra pagrindinė savybė, kartais kitos apskritimo savybės yra patogesnės tiesiogiai matuoti:

Chordo ilgio matavimas: Naudinga, kai turite fiksuotus taškus apskritime ir reikia apskaičiuoti spindulį.
Naudojant sektoriaus plotą arba lanką: Atvejais, susijusiuose su dalinėmis apskritimo dalimis.

Istorija

Apskritimų tyrinėjimas prasidėjo senovės civilizacijose:

Senovės geometrija: Apskritimas buvo tiriamas nuo senovės egiptiečių ir babiloniečių laikų.
Euklido elementai: Apie 300 m. pr. Kr. Euklidas apibrėžė apskritimą ir jo savybes savo svarbiausiame darbe Elementai.
Archimedas: Pateikė metodus, kaip apytiksliai apskaičiuoti (\pi) ir apskaičiavo plotus bei tūrius, susijusius su apskritimais ir sferomis.
(\pi) plėtra: Per šimtmečius matematikai, tokie kaip Liu Hui, Zu Chongzhi, Aryabhata ir galiausiai John Wallis ir Isaac Newton, patobulino (\pi) vertę ir supratimą.

Spindulys išlieka esminiu konceptu ne tik geometrijoje, bet ir fizikoje, inžinerijoje bei įvairiose taikomosiose mokslų srityse.

Pavyzdžiai

Čia pateikiami kodo pavyzdžiai keliomis programavimo kalbomis, skaičiuojant spindulį iš diametro, apskritimo ilgio ir ploto.

Iš diametro

Python

## Apskaičiuoti spindulį iš diametro
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("Diametras turi būti didesnis už nulį.")
    return diameter / 2

## Pavyzdžio naudojimas
d = 10
r = radius_from_diameter(d)
print(f"Spindulys yra {r} vienetai.")

JavaScript

// Apskaičiuoti spindulį iš diametro
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("Diametras turi būti didesnis už nulį.");
    }
    return diameter / 2;
}

// Pavyzdžio naudojimas
let d = 10;
let r = radiusFromDiameter(d);
console.log(`Spindulys yra ${r} vienetai.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("Diametras turi būti didesnis už nulį.");
        }
        return diameter / 2;
    }

    public static void main(String[] args) {
        double d = 10;
        double r = radiusFromDiameter(d);
        System.out.printf("Spindulys yra %.2f vienetai.%n", r);
    }
}

C++

// Apskaičiuoti spindulį iš diametro
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("Diametras turi būti didesnis už nulį.");
    }
    return diameter / 2.0;
}

int main() {
    double d = 10.0;
    try {
        double r = radiusFromDiameter(d);
        std::cout << "Spindulys yra " << r << " vienetai." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Apskaičiuoti spindulį iš diametro
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("Diametras turi būti didesnis už nulį.")
  }
  return(diameter / 2)
}

## Pavyzdžio naudojimas
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("Spindulys yra %.2f vienetai.\n", r))

Ruby

## Apskaičiuoti spindulį iš diametro
def radius_from_diameter(diameter)
  raise ArgumentError, "Diametras turi būti didesnis už nulį." if diameter <= 0
  diameter / 2.0
end

## Pavyzdžio naudojimas
d = 10
r = radius_from_diameter(d)
puts "Spindulys yra #{r} vienetai."

PHP

<?php
// Apskaičiuoti spindulį iš diametro
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('Diametras turi būti didesnis už nulį.');
    }
    return $diameter / 2;
}

// Pavyzdžio naudojimas
$d = 10;
$r = radiusFromDiameter($d);
echo "Spindulys yra {$r} vienetai.";
?>

Rust

// Apskaičiuoti spindulį iš diametro
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("Diametras turi būti didesnis už nulį.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("Spindulys yra {:.2} vienetai.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Apskaičiuoti spindulį iš diametro
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Diametras turi būti didesnis už nulį."])
    }
    return diameter / 2.0
}

// Pavyzdžio naudojimas
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("Spindulys yra \(r) vienetai.")
} catch {
    print(error.localizedDescription)
}

Iš apskritimo ilgio

Python

import math

## Apskaičiuoti spindulį iš apskritimo ilgio
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("Apskritimo ilgis turi būti didesnis už nulį.")
    return circumference / (2 * math.pi)

## Pavyzdžio naudojimas
C = 31.4159
r = radius_from_circumference(C)
print(f"Spindulys yra {r:.2f} vienetai.")

JavaScript

// Apskaičiuoti spindulį iš apskritimo ilgio
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("Apskritimo ilgis turi būti didesnis už nulį.");
    }
    return circumference / (2 * Math.PI);
}

// Pavyzdžio naudojimas
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`Spindulys yra ${r.toFixed(2)} vienetai.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("Apskritimo ilgis turi būti didesnis už nulį.");
        }
        return circumference / (2 * Math.PI);
    }

    public static void main(String[] args) {
        double C = 31.4159;
        double r = radiusFromCircumference(C);
        System.out.printf("Spindulys yra %.2f vienetai.%n", r);
    }
}

C++

// Apskaičiuoti spindulį iš apskritimo ilgio
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("Apskritimo ilgis turi būti didesnis už nulį.");
    }
    return circumference / (2.0 * M_PI);
}

int main() {
    double C = 31.4159;
    try {
        double r = radiusFromCircumference(C);
        std::cout << "Spindulys yra " << r << " vienetai." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Apskaičiuoti spindulį iš apskritimo ilgio
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("Apskritimo ilgis turi būti didesnis už nulį.")
  }
  return(circumference / (2 * pi))
}

## Pavyzdžio naudojimas
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("Spindulys yra %.2f vienetai.\n", r))

Ruby

## Apskaičiuoti spindulį iš apskritimo ilgio
def radius_from_circumference(circumference)
  raise ArgumentError, "Apskritimo ilgis turi būti didesnis už nulį." if circumference <= 0
  circumference / (2 * Math::PI)
end

## Pavyzdžio naudojimas
C = 31.4159
r = radius_from_circumference(C)
puts "Spindulys yra #{format('%.2f', r)} vienetai."

PHP

<?php
// Apskaičiuoti spindulį iš apskritimo ilgio
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('Apskritimo ilgis turi būti didesnis už nulį.');
    }
    return $circumference / (2 * M_PI);
}

// Pavyzdžio naudojimas
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "Spindulys yra " . round($r, 2) . " vienetai.";
?>

Rust

use std::f64::consts::PI;

// Apskaičiuoti spindulį iš apskritimo ilgio
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("Apskritimo ilgis turi būti didesnis už nulį.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("Spindulys yra {:.2} vienetai.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Apskaičiuoti spindulį iš apskritimo ilgio
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Apskritimo ilgis turi būti didesnis už nulį."])
    }
    return circumference / (2 * Double.pi)
}

// Pavyzdžio naudojimas
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "Spindulys yra %.2f vienetai.", r))
} catch {
    print(error.localizedDescription)
}

Iš ploto

Python

import math

## Apskaičiuoti spindulį iš ploto
def radius_from_area(area):
    if area <= 0:
        raise ValueError("Plotas turi būti didesnis už nulį.")
    return math.sqrt(area / math.pi)

## Pavyzdžio naudojimas
A = 78.5398
r = radius_from_area(A)
print(f"Spindulys yra {r:.2f} vienetai.")

JavaScript

// Apskaičiuoti spindulį iš ploto
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("Plotas turi būti didesnis už nulį.");
    }
    return Math.sqrt(area / Math.PI);
}

// Pavyzdžio naudojimas
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`Spindulys yra ${r.toFixed(2)} vienetai.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("Plotas turi būti didesnis už nulį.");
        }
        return Math.sqrt(area / Math.PI);
    }

    public static void main(String[] args) {
        double A = 78.5398;
        double r = radiusFromArea(A);
        System.out.printf("Spindulys yra %.2f vienetai.%n", r);
    }
}

C++

// Apskaičiuoti spindulį iš ploto
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("Plotas turi būti didesnis už nulį.");
    }
    return std::sqrt(area / M_PI);
}

int main() {
    double A = 78.5398;
    try {
        double r = radiusFromArea(A);
        std::cout << "Spindulys yra " << r << " vienetai." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Apskaičiuoti spindulį iš ploto
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("Plotas turi būti didesnis už nulį.")
  }
  return(sqrt(area / pi))
}

## Pavyzdžio naudojimas
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("Spindulys yra %.2f vienetai.\n", r))

MATLAB

% Apskaičiuoti spindulį iš ploto
function r = radius_from_area(area)
    if area <= 0
        error('Plotas turi būti didesnis už nulį.');
    end
    r = sqrt(area / pi);
end

% Pavyzdžio naudojimas
A = 78.5398;
r = radius_from_area(A);
fprintf('Spindulys yra %.2f vienetai.\n', r);

C#

using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("Plotas turi būti didesnis už nulį.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("Spindulys yra {0:F2} vienetai.", r);
    }
}

Go

package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("Plotas turi būti didesnis už nulį.")
	}
	return math.Sqrt(area / math.Pi), nil
}

func main() {
	A := 78.5398
	r, err := radiusFromArea(A)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("Spindulys yra %.2f vienetai.\n", r)
}

Ruby

## Apskaičiuoti spindulį iš ploto
def radius_from_area(area)
  raise ArgumentError, "Plotas turi būti didesnis už nulį." if area <= 0
  Math.sqrt(area / Math::PI)
end

## Pavyzdžio naudojimas
A = 78.5398
r = radius_from_area(A)
puts "Spindulys yra #{format('%.2f', r)} vienetai."

PHP

<?php
// Apskaičiuoti spindulį iš ploto
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('Plotas turi būti didesnis už nulį.');
    }
    return sqrt($area / M_PI);
}

// Pavyzdžio naudojimas
$A = 78.5398;
$r = radiusFromArea($A);
echo "Spindulys yra " . round($r, 2) . " vienetai.";
?>

Rust

use std::f64::consts::PI;

// Apskaičiuoti spindulį iš ploto
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("Plotas turi būti didesnis už nulį.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("Spindulys yra {:.2} vienetai.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Apskaičiuoti spindulį iš ploto
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Plotas turi būti didesnis už nulį."])
    }
    return sqrt(area / Double.pi)
}

// Pavyzdžio naudojimas
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "Spindulys yra %.2f vienetai.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## Apskaičiuoti spindulį iš diametro langelyje B1
=IF(B1>0, B1/2, "Neteisinga įvestis")

## Apskaičiuoti spindulį iš apskritimo ilgio langelyje B2
=IF(B2>0, B2/(2*PI()), "Neteisinga įvestis")

## Apskaičiuoti spindulį iš ploto langelyje B3
=IF(B3>0, SQRT(B3/PI()), "Neteisinga įvestis")

Vizualizacija

SVG diagrama, iliustruojanti ryšį tarp spindulio, diametro ir apskritimo ilgio:

Nuorodos

Apskritimas - Vikipedija
Apskritimo ilgis - Math Is Fun
Apskritimo plotas - Khan Academy
(\pi) istorija - Vikipedija

Susiję įrankiai

Teisingo apvalaus kūgio skaičiuoklė ir formulės

Cone Diameter Calculator: Find Diameter Using Height & Radius

Apskritimo matavimų skaičiuoklė: spindulys, skersmuo, plotas