Kalkulator promienia koła

Kalkulator Promienia Koła

Wprowadzenie

Promień koła jest jedną z jego najważniejszych właściwości. Jest to odległość od środka koła do dowolnego punktu na jego obwodzie. Ten kalkulator pozwala określić promień koła na podstawie trzech różnych parametrów wejściowych:

Średnica
Obwód
Pole

Podając dowolną z tych wartości, możesz obliczyć promień, korzystając z matematycznych zależności inherentnych w geometrii koła.

Wzór

Promień można obliczyć ze średnicy, obwodu lub pola, korzystając z następujących wzorów:

Ze Średnicy ( $d$ ):
$r = \frac{d}{2}$
Z Obwodu ( $C$ ):
$r = \frac{C}{2\pi}$
Z Pola ( $A$ ):
$r = \sqrt{\frac{A}{\pi}}$

Te wzory są wyprowadzone z podstawowych właściwości koła:

Średnica: Średnica jest dwa razy większa od promienia ( $d = 2r$ ).
Obwód: Obwód to odległość wokół koła ( $C = 2\pi r$ ).
Pole: Pole zamknięte przez koło ( $A = \pi r^2$ ).

Obliczenia

Obliczanie Promienia ze Średnicy

Podana średnica, promień to po prostu jej połowa:

r = \frac{d}{2}

Przykład:

Jeśli średnica wynosi 10 jednostek:

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

Obliczanie Promienia z Obwodu

Zaczynając od wzoru na obwód:

C = 2\pi r

Rozwiązując dla $r$ :

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

Przykład:

Jeśli obwód wynosi $31.4159$ jednostek:

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

Obliczanie Promienia z Pola

Zaczynając od wzoru na pole:

A = \pi r^2

Rozwiązując dla $r$ :

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

Przykład:

Jeśli pole wynosi $78.5398$ jednostek kwadratowych:

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

Przypadki Krawędzi i Walidacja Wejścia

Zera lub Ujemne Wejścia: Koło nie może mieć ujemnej lub zerowej średnicy, obwodu ani pola. Jeśli którakolwiek z tych wartości jest zerowa lub ujemna, promień jest niezdefiniowany. Kalkulator wyświetli w takich przypadkach komunikat o błędzie.
Wejścia Nienumeryczne: Kalkulator wymaga numerycznych wejść. Wartości nienumeryczne (np. litery lub symbole) są nieprawidłowe.

Precyzja i Zaokrąglanie

Ten kalkulator używa arytmetyki zmiennoprzecinkowej podwójnej precyzji do obliczeń. Wyniki są zazwyczaj wyświetlane zaokrąglone do czterech miejsc po przecinku dla większej dokładności. Przy użyciu stałych matematycznych, takich jak $\pi$ , kalkulator wykorzystuje pełną precyzję dostępną w języku programowania lub środowisku. Należy pamiętać, że arytmetyka zmiennoprzecinkowa może w niektórych przypadkach wprowadzać małe błędy zaokrągleń.

Przykłady Zastosowań

Obliczanie promienia koła jest istotne w różnych dziedzinach:

Inżynieria i Budownictwo

Projektowanie Komponentów Okrągłych: Inżynierowie często muszą określić promień przy projektowaniu kół, zębatek, rur lub kopuł.
Architektura: Architekci używają promienia do projektowania łuków, kopuł i okrągłych budynków.

Astronomia

Orbity Planetarne: Astronomowie obliczają promień orbit planetarnych na podstawie danych obserwacyjnych.
Ciała Niebieskie: Określenie rozmiarów planet, gwiazd i innych obiektów niebieskich.

Rozwiązywanie Codziennych Problemów

Sztuka i Projektowanie: Artyści i projektanci obliczają promień, aby tworzyć okrągłe wzory i projekty.
Projekty DIY: Obliczanie materiałów potrzebnych do okrągłych stołów, ogrodów lub fontann.

Matematyka i Edukacja

Nauka Geometrii: Zrozumienie właściwości kół jest fundamentalne w edukacji geometrycznej.
Rozwiązywanie Problemów: Obliczenia promienia są powszechne w problemach matematycznych i zawodach.

Alternatywy

Chociaż promień jest podstawową właściwością, czasami inne właściwości koła są wygodniejsze do bezpośredniego zmierzenia:

Mierzenie Długości Chordu: Przydatne, gdy masz stałe punkty na kole i musisz obliczyć promień.
Używanie Powierzchni Sektora lub Długości Łuku: W przypadkach dotyczących częściowych sekcji koła.

Historia

Badanie kół sięga starożytnych cywilizacji:

Starożytna Geometria: Koło było badane od czasów starożytnych Egipcjan i Babilończyków.
Elementy Euklidesa: Około 300 roku p.n.e. Euklides zdefiniował koło i jego właściwości w swoim przełomowym dziele, Elementy.
Archimedes: Opracował metody przybliżania (\pi) i obliczał pola i objętości związane z kołami i sferami.
Rozwój (\pi): Na przestrzeni wieków matematycy, tacy jak Liu Hui, Zu Chongzhi, Aryabhata, a ostatecznie John Wallis i Isaac Newton, udoskonalili wartość i zrozumienie (\pi).

Promień pozostaje fundamentalnym pojęciem nie tylko w geometrii, ale także w fizyce, inżynierii i różnych naukach stosowanych.

Przykłady

Oto przykłady kodu w wielu językach programowania do obliczania promienia ze średnicy, obwodu i pola.

Ze Średnicy

Python

## Obliczanie promienia ze średnicy
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("Średnica musi być większa od zera.")
    return diameter / 2

## Przykład użycia
d = 10
r = radius_from_diameter(d)
print(f"Promień wynosi {r} jednostek.")

JavaScript

// Obliczanie promienia ze średnicy
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("Średnica musi być większa od zera.");
    }
    return diameter / 2;
}

// Przykład użycia
let d = 10;
let r = radiusFromDiameter(d);
console.log(`Promień wynosi ${r} jednostek.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("Średnica musi być większa od zera.");
        }
        return diameter / 2;
    }

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

C++

// Obliczanie promienia ze średnicy
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("Średnica musi być większa od zera.");
    }
    return diameter / 2.0;
}

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

R

## Obliczanie promienia ze średnicy
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("Średnica musi być większa od zera.")
  }
  return(diameter / 2)
}

## Przykład użycia
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("Promień wynosi %.2f jednostek.\n", r))

Ruby

## Obliczanie promienia ze średnicy
def radius_from_diameter(diameter)
  raise ArgumentError, "Średnica musi być większa od zera." if diameter <= 0
  diameter / 2.0
end

## Przykład użycia
d = 10
r = radius_from_diameter(d)
puts "Promień wynosi #{r} jednostek."

PHP

<?php
// Obliczanie promienia ze średnicy
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('Średnica musi być większa od zera.');
    }
    return $diameter / 2;
}

// Przykład użycia
$d = 10;
$r = radiusFromDiameter($d);
echo "Promień wynosi {$r} jednostek.";
?>

Rust

// Obliczanie promienia ze średnicy
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("Średnica musi być większa od zera.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("Promień wynosi {:.2} jednostek.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Obliczanie promienia ze średnicy
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Średnica musi być większa od zera."])
    }
    return diameter / 2.0
}

// Przykład użycia
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("Promień wynosi \(r) jednostek.")
} catch {
    print(error.localizedDescription)
}

Z Obwodu

Python

import math

## Obliczanie promienia z obwodu
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("Obwód musi być większy od zera.")
    return circumference / (2 * math.pi)

## Przykład użycia
C = 31.4159
r = radius_from_circumference(C)
print(f"Promień wynosi {r:.2f} jednostek.")

JavaScript

// Obliczanie promienia z obwodu
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("Obwód musi być większy od zera.");
    }
    return circumference / (2 * Math.PI);
}

// Przykład użycia
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`Promień wynosi ${r.toFixed(2)} jednostek.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("Obwód musi być większy od zera.");
        }
        return circumference / (2 * Math.PI);
    }

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

C++

// Obliczanie promienia z obwodu
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("Obwód musi być większy od zera.");
    }
    return circumference / (2.0 * M_PI);
}

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

R

## Obliczanie promienia z obwodu
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("Obwód musi być większy od zera.")
  }
  return(circumference / (2 * pi))
}

## Przykład użycia
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("Promień wynosi %.2f jednostek.\n", r))

Ruby

## Obliczanie promienia z obwodu
def radius_from_circumference(circumference)
  raise ArgumentError, "Obwód musi być większy od zera." if circumference <= 0
  circumference / (2 * Math::PI)
end

## Przykład użycia
C = 31.4159
r = radius_from_circumference(C)
puts "Promień wynosi #{format('%.2f', r)} jednostek."

PHP

<?php
// Obliczanie promienia z obwodu
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('Obwód musi być większy od zera.');
    }
    return $circumference / (2 * M_PI);
}

// Przykład użycia
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "Promień wynosi " . round($r, 2) . " jednostek.";
?>

Rust

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

// Obliczanie promienia z obwodu
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("Obwód musi być większy od zera.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("Promień wynosi {:.2} jednostek.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Obliczanie promienia z obwodu
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Obwód musi być większy od zera."])
    }
    return circumference / (2 * Double.pi)
}

// Przykład użycia
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "Promień wynosi %.2f jednostek.", r))
} catch {
    print(error.localizedDescription)
}

Z Pola

Python

import math

## Obliczanie promienia z pola
def radius_from_area(area):
    if area <= 0:
        raise ValueError("Pole musi być większe od zera.")
    return math.sqrt(area / math.pi)

## Przykład użycia
A = 78.5398
r = radius_from_area(A)
print(f"Promień wynosi {r:.2f} jednostek.")

JavaScript

// Obliczanie promienia z pola
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("Pole musi być większe od zera.");
    }
    return Math.sqrt(area / Math.PI);
}

// Przykład użycia
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`Promień wynosi ${r.toFixed(2)} jednostek.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("Pole musi być większe od zera.");
        }
        return Math.sqrt(area / Math.PI);
    }

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

C++

// Obliczanie promienia z pola
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("Pole musi być większe od zera.");
    }
    return std::sqrt(area / M_PI);
}

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

R

## Obliczanie promienia z pola
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("Pole musi być większe od zera.")
  }
  return(sqrt(area / pi))
}

## Przykład użycia
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("Promień wynosi %.2f jednostek.\n", r))

MATLAB

% Obliczanie promienia z pola
function r = radius_from_area(area)
    if area <= 0
        error('Pole musi być większe od zera.');
    end
    r = sqrt(area / pi);
end

% Przykład użycia
A = 78.5398;
r = radius_from_area(A);
fprintf('Promień wynosi %.2f jednostek.\n', r);

C#

using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("Pole musi być większe od zera.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("Promień wynosi {0:F2} jednostek.", r);
    }
}

Go

package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("Pole musi być większe od zera.")
	}
	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("Promień wynosi %.2f jednostek.\n", r)
}

Ruby

## Obliczanie promienia z pola
def radius_from_area(area)
  raise ArgumentError, "Pole musi być większe od zera." if area <= 0
  Math.sqrt(area / Math::PI)
end

## Przykład użycia
A = 78.5398
r = radius_from_area(A)
puts "Promień wynosi #{format('%.2f', r)} jednostek."

PHP

<?php
// Obliczanie promienia z pola
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('Pole musi być większe od zera.');
    }
    return sqrt($area / M_PI);
}

// Przykład użycia
$A = 78.5398;
$r = radiusFromArea($A);
echo "Promień wynosi " . round($r, 2) . " jednostek.";
?>

Rust

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

// Obliczanie promienia z pola
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("Pole musi być większe od zera.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("Promień wynosi {:.2} jednostek.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Obliczanie promienia z pola
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Pole musi być większe od zera."])
    }
    return sqrt(area / Double.pi)
}

// Przykład użycia
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "Promień wynosi %.2f jednostek.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## Obliczanie promienia ze średnicy w komórce B1
=IF(B1>0, B1/2, "Nieprawidłowe wejście")

## Obliczanie promienia z obwodu w komórce B2
=IF(B2>0, B2/(2*PI()), "Nieprawidłowe wejście")

## Obliczanie promienia z pola w komórce B3
=IF(B3>0, SQRT(B3/PI()), "Nieprawidłowe wejście")

Wizualizacja

Diagram SVG ilustrujący związek między promieniem, średnicą i obwodem:

Źródła

Koło - Wikipedia
Obwód - Matematyka jest fajna
Pole Koła - Khan Academy
Historia (\pi) - Wikipedia

Powiązane narzędzia

Kalkulator do obliczania stożka prawidłowego i jego wymiarów

Kalkulator średnicy stożka - obliczaj łatwo i szybko

Kalkulator Pomiarów Okręgu - Oblicz promień i obwód