Kör Sugár Számító Eszköz - Gyors és Egyszerű Módszer

Kör Sugár Számító

Bevezetés

A sugár a kör egyik legfontosabb tulajdonsága. Ez a távolság a kör középpontjától bármely pontig a kör kerületén. Ez a számító lehetővé teszi, hogy meghatározza a kör sugarát három különböző bemeneti paraméter alapján:

Átmérő
Kerület
Terület

Bármelyik érték megadásával kiszámíthatja a sugarat a körgeometria alapvető matematikai kapcsolatai segítségével.

Képlet

A sugár kiszámítható az átmérő, kerület vagy terület alapján az alábbi képletek segítségével:

Átmérőből ( $d$ ):
$r = \frac{d}{2}$
Kerületből ( $C$ ):
$r = \frac{C}{2\pi}$
Területből ( $A$ ):
$r = \sqrt{\frac{A}{\pi}}$

Ezek a képletek a kör alapvető tulajdonságaiból származnak:

Átmérő: Az átmérő kétszerese a sugárnak ( $d = 2r$ ).
Kerület: A kerület a kör körüli távolság ( $C = 2\pi r$ ).
Terület: A kör által körülhatárolt terület ( $A = \pi r^2$ ).

Számítás

Sugár Kiszámítása Átmérőből

Adott az átmérő, a sugár egyszerűen annak fele:

r = \frac{d}{2}

Példa:

Ha az átmérő 10 egység:

r = \frac{10}{2} = 5 \text{ egység}

Sugár Kiszámítása Kerületből

Kezdve a kerület képlettel:

C = 2\pi r

Megoldva $r$ -t:

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

Példa:

Ha a kerület $31.4159$ egység:

r = \frac{31.4159}{2\pi} \approx \frac{31.4159}{6.2832} \approx 5 \text{ egység}

Sugár Kiszámítása Területből

Kezdve a terület képlettel:

A = \pi r^2

Megoldva $r$ -t:

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

Példa:

Ha a terület $78.5398$ négyzetegység:

r = \sqrt{\frac{78.5398}{\pi}} = \sqrt{\frac{78.5398}{3.1416}} \approx \sqrt{25} = 5 \text{ egység}

Széljegyzetek és Bemeneti Ellenőrzés

Nulla vagy Negatív Bemenetek: A körnek nem lehet negatív vagy nulla átmérője, kerülete vagy területe. Ha bármelyik érték nulla vagy negatív, a sugár nem meghatározható. A számító ilyen esetekben hibaüzenetet fog megjeleníteni.
Nem Numerikus Bemenetek: A számító numerikus bemeneteket igényel. A nem numerikus értékek (pl. betűk vagy szimbólumok) érvénytelenek.

Pontosság és Kerekítés

Ez a számító dupla pontosságú lebegőpontos aritmetikát használ a számításokhoz. Az eredményeket általában négy tizedesjegyig kerekítve jelenítik meg a nagyobb pontosság érdekében. Matematikai állandók, mint például $\pi$ használatakor a számító a programozási nyelv vagy környezet által elérhető teljes pontosságot használja. Legyen tudatában, hogy a lebegőpontos aritmetika kis kerekítési hibákat okozhat egyes esetekben.

Használati Esetek

A kör sugárának kiszámítása számos területen alapvető fontosságú:

Mérnöki és Építkezési

Kör alakú Elemeinek Tervezése: A mérnökök gyakran szükségesnek találják a sugár meghatározását kerekek, fogaskerekek, csövek vagy kupolák tervezésekor.
Építészet: Az építészek a sugarat használják ívek, kupolák és kör alakú épületek tervezéséhez.

Csillagászat

Bolygók Keringése: A csillagászok a bolygók keringésének sugarát számítják ki megfigyelési adatok alapján.
Égi Testek: A bolygók, csillagok és más égi objektumok méretének meghatározása.

Mindennapi Problémamegoldás

Művészet és Tervezés: Művészek és tervezők a sugár kiszámításával készítenek kör alakú mintákat és terveket.
DIY Projektek: Anyagok kiszámítása kör alakú asztalok, kertek vagy szökőkutak számára.

Matematika és Oktatás

Geometria Tanulása: A kör tulajdonságainak megértése alapvető fontosságú a geometriai oktatásban.
Problémamegoldás: A sugár számítása gyakori a matematikai problémákban és versenyeken.

Alternatívák

Bár a sugár egy alapvető tulajdonság, néha más kör tulajdonságokat kényelmesebb közvetlenül mérni:

Kord Hossza: Hasznos, ha rögzített pontok vannak a körön, és szükséges a sugár kiszámítása.
Szelet Területe vagy Ív Hossza: Olyan esetekben, amikor a kör részleges szakaszaival foglalkozunk.

Történelem

A kör tanulmányozása az ókori civilizációkig nyúlik vissza:

Ókori Geometria: A kört már az ókori egyiptomiak és babilóniaiak idejében tanulmányozták.
Euklidész Elemei: Kr.e. 300 körül Euklidész meghatározta a kört és annak tulajdonságait alapművében, az Elemeiben.
Arkhimédész: Módszereket adott a $\pi$ közelítésére és a körökhöz és gömbökhöz kapcsolódó területek és térfogatok kiszámítására.
A $\pi$ Fejlődése: Az évszázadok során matematikusok, mint Liu Hui, Zu Chongzhi, Aryabhata, végül John Wallis és Isaac Newton finomították a $\pi$ értékét és megértését.

A sugár továbbra is alapvető fogalom nemcsak a geometriában, hanem a fizika, mérnöki tudományok és különböző alkalmazott tudományok területén is.

Példák

Itt vannak kód példák több programozási nyelven a sugár kiszámítására átmérő, kerület és terület alapján.

Átmérőből

Python

## Sugár kiszámítása átmérőből
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("Az átmérőnek nagyobbnak kell lennie nullánál.")
    return diameter / 2

## Példa használat
d = 10
r = radius_from_diameter(d)
print(f"A sugár {r} egység.")

JavaScript

// Sugár kiszámítása átmérőből
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("Az átmérőnek nagyobbnak kell lennie nullánál.");
    }
    return diameter / 2;
}

// Példa használat
let d = 10;
let r = radiusFromDiameter(d);
console.log(`A sugár ${r} egység.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("Az átmérőnek nagyobbnak kell lennie nullánál.");
        }
        return diameter / 2;
    }

    public static void main(String[] args) {
        double d = 10;
        double r = radiusFromDiameter(d);
        System.out.printf("A sugár %.2f egység.%n", r);
    }
}

C++

// Sugár kiszámítása átmérőből
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("Az átmérőnek nagyobbnak kell lennie nullánál.");
    }
    return diameter / 2.0;
}

int main() {
    double d = 10.0;
    try {
        double r = radiusFromDiameter(d);
        std::cout << "A sugár " << r << " egység." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Sugár kiszámítása átmérőből
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("Az átmérőnek nagyobbnak kell lennie nullánál.")
  }
  return(diameter / 2)
}

## Példa használat
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("A sugár %.2f egység.\n", r))

Ruby

## Sugár kiszámítása átmérőből
def radius_from_diameter(diameter)
  raise ArgumentError, "Az átmérőnek nagyobbnak kell lennie nullánál." if diameter <= 0
  diameter / 2.0
end

## Példa használat
d = 10
r = radius_from_diameter(d)
puts "A sugár #{r} egység."

PHP

<?php
// Sugár kiszámítása átmérőből
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('Az átmérőnek nagyobbnak kell lennie nullánál.');
    }
    return $diameter / 2;
}

// Példa használat
$d = 10;
$r = radiusFromDiameter($d);
echo "A sugár {$r} egység.";
?>

Rust

// Sugár kiszámítása átmérőből
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("Az átmérőnek nagyobbnak kell lennie nullánál.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("A sugár {:.2} egység.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Sugár kiszámítása átmérőből
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Az átmérőnek nagyobbnak kell lennie nullánál."])
    }
    return diameter / 2.0
}

// Példa használat
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("A sugár \(r) egység.")
} catch {
    print(error.localizedDescription)
}

Kerületből

Python

import math

## Sugár kiszámítása kerületből
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("A kerületnek nagyobbnak kell lennie nullánál.")
    return circumference / (2 * math.pi)

## Példa használat
C = 31.4159
r = radius_from_circumference(C)
print(f"A sugár {r:.2f} egység.")

JavaScript

// Sugár kiszámítása kerületből
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("A kerületnek nagyobbnak kell lennie nullánál.");
    }
    return circumference / (2 * Math.PI);
}

// Példa használat
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`A sugár ${r.toFixed(2)} egység.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("A kerületnek nagyobbnak kell lennie nullánál.");
        }
        return circumference / (2 * Math.PI);
    }

    public static void main(String[] args) {
        double C = 31.4159;
        double r = radiusFromCircumference(C);
        System.out.printf("A sugár %.2f egység.%n", r);
    }
}

C++

// Sugár kiszámítása kerületből
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("A kerületnek nagyobbnak kell lennie nullánál.");
    }
    return circumference / (2.0 * M_PI);
}

int main() {
    double C = 31.4159;
    try {
        double r = radiusFromCircumference(C);
        std::cout << "A sugár " << r << " egység." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Sugár kiszámítása kerületből
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("A kerületnek nagyobbnak kell lennie nullánál.")
  }
  return(circumference / (2 * pi))
}

## Példa használat
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("A sugár %.2f egység.\n", r))

Ruby

## Sugár kiszámítása kerületből
def radius_from_circumference(circumference)
  raise ArgumentError, "A kerületnek nagyobbnak kell lennie nullánál." if circumference <= 0
  circumference / (2 * Math::PI)
end

## Példa használat
C = 31.4159
r = radius_from_circumference(C)
puts "A sugár #{format('%.2f', r)} egység."

PHP

<?php
// Sugár kiszámítása kerületből
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('A kerületnek nagyobbnak kell lennie nullánál.');
    }
    return $circumference / (2 * M_PI);
}

// Példa használat
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "A sugár " . round($r, 2) . " egység.";
?>

Rust

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

// Sugár kiszámítása kerületből
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("A kerületnek nagyobbnak kell lennie nullánál.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("A sugár {:.2} egység.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Sugár kiszámítása kerületből
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "A kerületnek nagyobbnak kell lennie nullánál."])
    }
    return circumference / (2 * Double.pi)
}

// Példa használat
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "A sugár %.2f egység.", r))
} catch {
    print(error.localizedDescription)
}

Területből

Python

import math

## Sugár kiszámítása területből
def radius_from_area(area):
    if area <= 0:
        raise ValueError("A területnek nagyobbnak kell lennie nullánál.")
    return math.sqrt(area / math.pi)

## Példa használat
A = 78.5398
r = radius_from_area(A)
print(f"A sugár {r:.2f} egység.")

JavaScript

// Sugár kiszámítása területből
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("A területnek nagyobbnak kell lennie nullánál.");
    }
    return Math.sqrt(area / Math.PI);
}

// Példa használat
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`A sugár ${r.toFixed(2)} egység.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("A területnek nagyobbnak kell lennie nullánál.");
        }
        return Math.sqrt(area / Math.PI);
    }

    public static void main(String[] args) {
        double A = 78.5398;
        double r = radiusFromArea(A);
        System.out.printf("A sugár %.2f egység.%n", r);
    }
}

C++

// Sugár kiszámítása területből
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("A területnek nagyobbnak kell lennie nullánál.");
    }
    return std::sqrt(area / M_PI);
}

int main() {
    double A = 78.5398;
    try {
        double r = radiusFromArea(A);
        std::cout << "A sugár " << r << " egység." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Sugár kiszámítása területből
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("A területnek nagyobbnak kell lennie nullánál.")
  }
  return(sqrt(area / pi))
}

## Példa használat
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("A sugár %.2f egység.\n", r))

MATLAB

% Sugár kiszámítása területből
function r = radius_from_area(area)
    if area <= 0
        error('A területnek nagyobbnak kell lennie nullánál.');
    end
    r = sqrt(area / pi);
end

% Példa használat
A = 78.5398;
r = radius_from_area(A);
fprintf('A sugár %.2f egység.\n', r);

C#

using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("A területnek nagyobbnak kell lennie nullánál.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("A sugár {0:F2} egység.", r);
    }
}

Go

package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("A területnek nagyobbnak kell lennie nullánál.")
	}
	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("A sugár %.2f egység.\n", r)
}

Ruby

## Sugár kiszámítása területből
def radius_from_area(area)
  raise ArgumentError, "A területnek nagyobbnak kell lennie nullánál." if area <= 0
  Math.sqrt(area / Math::PI)
end

## Példa használat
A = 78.5398
r = radius_from_area(A)
puts "A sugár #{format('%.2f', r)} egység."

PHP

<?php
// Sugár kiszámítása területből
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('A területnek nagyobbnak kell lennie nullánál.');
    }
    return sqrt($area / M_PI);
}

// Példa használat
$A = 78.5398;
$r = radiusFromArea($A);
echo "A sugár " . round($r, 2) . " egység.";
?>

Rust

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

// Sugár kiszámítása területből
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("A területnek nagyobbnak kell lennie nullánál.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("A sugár {:.2} egység.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Sugár kiszámítása területből
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "A területnek nagyobbnak kell lennie nullánál."])
    }
    return sqrt(area / Double.pi)
}

// Példa használat
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "A sugár %.2f egység.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## Sugár kiszámítása átmérőből a B1 cellában
=IF(B1>0, B1/2, "Érvénytelen bemenet")

## Sugár kiszámítása kerületből a B2 cellában
=IF(B2>0, B2/(2*PI()), "Érvénytelen bemenet")

## Sugár kiszámítása területből a B3 cellában
=IF(B3>0, SQRT(B3/PI()), "Érvénytelen bemenet")

Vizualizáció

Egy SVG diagram, amely illusztrálja a sugár, átmérő és kerület közötti kapcsolatot:

Hivatkozások

Kör - Wikipedia
Kerület - Matematika Szórakoztatóan
Kör Területe - Khan Akadémia
A $\pi$ Története - Wikipedia

Kapcsolódó Eszközök

Jobb körkúp kalkulátor - Felület és térfogat számítás

Kúp Átmérő Számító: Magasság és Sugár Alapján

Körmérés Kalkulátor: Sugár, Átmérő, Kerület és Terület