Whiz Tools

Radius of a Circle Calculator

Introduksjon

Radius av en sirkel er en av dens mest grunnleggende egenskaper. Det er avstanden fra sentrum av sirkelen til et hvilket som helst punkt på omkretsen. Denne kalkulatoren lar deg bestemme radiusen til en sirkel basert på tre forskjellige inndata-parametere:

  1. Diameter
  2. Omkrets
  3. Areal

Ved å gi hvilken som helst av disse verdiene, kan du beregne radiusen ved hjelp av de matematiske forholdene som er iboende i sirkels geometri.

Formel

Radiusen kan beregnes fra diameteren, omkretsen eller arealet ved hjelp av følgende formler:

  1. Fra Diameter (dd):

    r=d2r = \frac{d}{2}
  2. Fra Omkrets (CC):

    r=C2πr = \frac{C}{2\pi}
  3. Fra Areal (AA):

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

Disse formlene er avledet fra de grunnleggende egenskapene til en sirkel:

  • Diameter: Diameteren er dobbelt så stor som radius (d=2rd = 2r).
  • Omkrets: Omkretsen er avstanden rundt sirkelen (C=2πrC = 2\pi r).
  • Areal: Arealet som er innelukket av sirkelen (A=πr2A = \pi r^2).

Beregning

Beregning av Radius fra Diameter

Gitt diameteren, er radiusen ganske enkelt halvparten av den:

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

Eksempel:

Hvis diameteren er 10 enheter:

r=102=5 enheterr = \frac{10}{2} = 5 \text{ enheter}

Beregning av Radius fra Omkrets

Starter med omkretsformelen:

C=2πrC = 2\pi r

Løser for rr:

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

Eksempel:

Hvis omkretsen er 31.415931.4159 enheter:

r=31.41592π31.41596.28325 enheterr = \frac{31.4159}{2\pi} \approx \frac{31.4159}{6.2832} \approx 5 \text{ enheter}

Beregning av Radius fra Areal

Starter med arealformelen:

A=πr2A = \pi r^2

Løser for rr:

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

Eksempel:

Hvis arealet er 78.539878.5398 kvadratenheter:

r=78.5398π=78.53983.141625=5 enheterr = \sqrt{\frac{78.5398}{\pi}} = \sqrt{\frac{78.5398}{3.1416}} \approx \sqrt{25} = 5 \text{ enheter}

Grenseverdier og Inndata Validering

  • Null eller Negative Inndata: En sirkel kan ikke ha en negativ eller null diameter, omkrets eller areal. Hvis noen av disse verdiene er null eller negative, er radiusen udefinert. Kalkulatoren vil vise en feilmelding i slike tilfeller.

  • Ikke-numeriske Inndata: Kalkulatoren krever numeriske inndata. Ikke-numeriske verdier (f.eks. bokstaver eller symboler) er ugyldige.

Presisjon og Avrunding

Denne kalkulatoren bruker dobbel presisjon flyttallsaritmetikk for beregninger. Resultater vises vanligvis avrundet til fire desimaler for større nøyaktighet. Når man bruker matematiske konstanter som π\pi, benytter kalkulatoren den fulle presisjonen som er tilgjengelig i programmeringsspråket eller miljøet. Vær oppmerksom på at flyttallsaritmetikk kan introdusere små avrundingsfeil i noen tilfeller.

Bruksområder

Å beregne radiusen til en sirkel er essensielt i ulike felt:

Ingeniørfag og Konstruksjon

  • Design av Sirkulære Komponenter: Ingeniører må ofte bestemme radiusen når de designer hjul, gir, rør eller kupler.

  • Arkitektur: Arkitekter bruker radiusen til å designe buer, kupler og sirkulære bygninger.

Astronomi

  • Planetariske Baner: Astronomer beregner radiusen til planetariske baner basert på observasjonsdata.

  • Himmelkropper: Bestemme størrelsene på planeter, stjerner og andre himmellegemer.

Hverdags Problemløsning

  • Kunst og Design: Kunstnere og designere beregner radiusen for å lage sirkulære mønstre og design.

  • Gjør-det-selv Prosjekter: Beregning av materialer som trengs til sirkulære bord, hager eller fontener.

Matematikk og Utdanning

  • Læring av Geometri: Å forstå egenskapene til sirkler er grunnleggende i geometriutdanning.

  • Problemløsning: Radiusberegninger er vanlige i matematiske problemer og konkurranser.

Alternativer

Selv om radiusen er en primær egenskap, er det noen ganger andre sirkeleegenskaper som er mer praktiske å måle direkte:

  • Måling av Kordlengde: Nyttig når du har faste punkter på en sirkel og trenger å beregne radiusen.

  • Bruke Sektorareal eller Bue Lengde: I tilfeller som involverer delvise seksjoner av en sirkel.

Historie

Studiet av sirkler går tilbake til gamle sivilisasjoner:

  • Gammel Geometri: Sirkelen har vært studert siden tiden til de gamle egypterne og babylonerne.

  • Euklids Elementer: Rundt 300 f.Kr. definerte Euklid sirkelen og dens egenskaper i sitt banebrytende verk, Elementer.

  • Archimedes: Ga metoder for å tilnærme (\pi) og beregnet arealer og volum relatert til sirkler og sfærer.

  • Utvikling av (\pi): Gjennom århundrene har matematikere som Liu Hui, Zu Chongzhi, Aryabhata, og til slutt John Wallis og Isaac Newton raffinert verdien og forståelsen av (\pi).

Radiusen forblir et grunnleggende konsept ikke bare i geometri, men også på tvers av fysikk, ingeniørfag og ulike anvendte vitenskaper.

Eksempler

Her er kodeeksempler i flere programmeringsspråk for å beregne radius fra diameter, omkrets og areal.

Fra Diameter

Python
## Beregn radius fra diameter
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("Diameter må være større enn null.")
    return diameter / 2

## Eksempelbruk
d = 10
r = radius_from_diameter(d)
print(f"Radiusen er {r} enheter.")
JavaScript
// Beregn radius fra diameter
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("Diameter må være større enn null.");
    }
    return diameter / 2;
}

// Eksempelbruk
let d = 10;
let r = radiusFromDiameter(d);
console.log(`Radiusen er ${r} enheter.`);
Java
public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("Diameter må være større enn null.");
        }
        return diameter / 2;
    }

    public static void main(String[] args) {
        double d = 10;
        double r = radiusFromDiameter(d);
        System.out.printf("Radiusen er %.2f enheter.%n", r);
    }
}
C++
// Beregn radius fra diameter
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("Diameter må være større enn null.");
    }
    return diameter / 2.0;
}

int main() {
    double d = 10.0;
    try {
        double r = radiusFromDiameter(d);
        std::cout << "Radiusen er " << r << " enheter." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}
R
## Beregn radius fra diameter
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("Diameter må være større enn null.")
  }
  return(diameter / 2)
}

## Eksempelbruk
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("Radiusen er %.2f enheter.\n", r))
Ruby
## Beregn radius fra diameter
def radius_from_diameter(diameter)
  raise ArgumentError, "Diameter må være større enn null." if diameter <= 0
  diameter / 2.0
end

## Eksempelbruk
d = 10
r = radius_from_diameter(d)
puts "Radiusen er #{r} enheter."
PHP
<?php
// Beregn radius fra diameter
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('Diameter må være større enn null.');
    }
    return $diameter / 2;
}

// Eksempelbruk
$d = 10;
$r = radiusFromDiameter($d);
echo "Radiusen er {$r} enheter.";
?>
Rust
// Beregn radius fra diameter
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("Diameter må være større enn null.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("Radiusen er {:.2} enheter.", r),
        Err(e) => println!("{}", e),
    }
}
Swift
import Foundation

// Beregn radius fra diameter
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Diameter må være større enn null."])
    }
    return diameter / 2.0
}

// Eksempelbruk
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("Radiusen er \(r) enheter.")
} catch {
    print(error.localizedDescription)
}

Fra Omkrets

Python
import math

## Beregn radius fra omkrets
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("Omkrets må være større enn null.")
    return circumference / (2 * math.pi)

## Eksempelbruk
C = 31.4159
r = radius_from_circumference(C)
print(f"Radiusen er {r:.2f} enheter.")
JavaScript
// Beregn radius fra omkrets
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("Omkrets må være større enn null.");
    }
    return circumference / (2 * Math.PI);
}

// Eksempelbruk
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`Radiusen er ${r.toFixed(2)} enheter.`);
Java
public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("Omkrets må være større enn null.");
        }
        return circumference / (2 * Math.PI);
    }

    public static void main(String[] args) {
        double C = 31.4159;
        double r = radiusFromCircumference(C);
        System.out.printf("Radiusen er %.2f enheter.%n", r);
    }
}
C++
// Beregn radius fra omkrets
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("Omkrets må være større enn null.");
    }
    return circumference / (2.0 * M_PI);
}

int main() {
    double C = 31.4159;
    try {
        double r = radiusFromCircumference(C);
        std::cout << "Radiusen er " << r << " enheter." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}
R
## Beregn radius fra omkrets
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("Omkrets må være større enn null.")
  }
  return(circumference / (2 * pi))
}

## Eksempelbruk
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("Radiusen er %.2f enheter.\n", r))
Ruby
## Beregn radius fra omkrets
def radius_from_circumference(circumference)
  raise ArgumentError, "Omkrets må være større enn null." if circumference <= 0
  circumference / (2 * Math::PI)
end

## Eksempelbruk
C = 31.4159
r = radius_from_circumference(C)
puts "Radiusen er #{format('%.2f', r)} enheter."
PHP
<?php
// Beregn radius fra omkrets
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('Omkrets må være større enn null.');
    }
    return $circumference / (2 * M_PI);
}

// Eksempelbruk
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "Radiusen er " . round($r, 2) . " enheter.";
?>
Rust
use std::f64::consts::PI;

// Beregn radius fra omkrets
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("Omkrets må være større enn null.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("Radiusen er {:.2} enheter.", r),
        Err(e) => println!("{}", e),
    }
}
Swift
import Foundation

// Beregn radius fra omkrets
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Omkrets må være større enn null."])
    }
    return circumference / (2 * Double.pi)
}

// Eksempelbruk
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "Radiusen er %.2f enheter.", r))
} catch {
    print(error.localizedDescription)
}

Fra Areal

Python
import math

## Beregn radius fra areal
def radius_from_area(area):
    if area <= 0:
        raise ValueError("Areal må være større enn null.")
    return math.sqrt(area / math.pi)

## Eksempelbruk
A = 78.5398
r = radius_from_area(A)
print(f"Radiusen er {r:.2f} enheter.")
JavaScript
// Beregn radius fra areal
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("Areal må være større enn null.");
    }
    return Math.sqrt(area / Math.PI);
}

// Eksempelbruk
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`Radiusen er ${r.toFixed(2)} enheter.`);
Java
public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("Areal må være større enn null.");
        }
        return Math.sqrt(area / Math.PI);
    }

    public static void main(String[] args) {
        double A = 78.5398;
        double r = radiusFromArea(A);
        System.out.printf("Radiusen er %.2f enheter.%n", r);
    }
}
C++
// Beregn radius fra areal
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("Areal må være større enn null.");
    }
    return std::sqrt(area / M_PI);
}

int main() {
    double A = 78.5398;
    try {
        double r = radiusFromArea(A);
        std::cout << "Radiusen er " << r << " enheter." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}
R
## Beregn radius fra areal
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("Areal må være større enn null.")
  }
  return(sqrt(area / pi))
}

## Eksempelbruk
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("Radiusen er %.2f enheter.\n", r))
MATLAB
% Beregn radius fra areal
function r = radius_from_area(area)
    if area <= 0
        error('Areal må være større enn null.');
    end
    r = sqrt(area / pi);
end

% Eksempelbruk
A = 78.5398;
r = radius_from_area(A);
fprintf('Radiusen er %.2f enheter.\n', r);
C#
using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("Areal må være større enn null.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("Radiusen er {0:F2} enheter.", r);
    }
}
Go
package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("Areal må være større enn null.")
	}
	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("Radiusen er %.2f enheter.\n", r)
}
Ruby
## Beregn radius fra areal
def radius_from_area(area)
  raise ArgumentError, "Areal må være større enn null." if area <= 0
  Math.sqrt(area / Math::PI)
end

## Eksempelbruk
A = 78.5398
r = radius_from_area(A)
puts "Radiusen er #{format('%.2f', r)} enheter."
PHP
<?php
// Beregn radius fra areal
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('Areal må være større enn null.');
    }
    return sqrt($area / M_PI);
}

// Eksempelbruk
$A = 78.5398;
$r = radiusFromArea($A);
echo "Radiusen er " . round($r, 2) . " enheter.";
?>
Rust
use std::f64::consts::PI;

// Beregn radius fra areal
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("Areal må være større enn null.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("Radiusen er {:.2} enheter.", r),
        Err(e) => println!("{}", e),
    }
}
Swift
import Foundation

// Beregn radius fra areal
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Areal må være større enn null."])
    }
    return sqrt(area / Double.pi)
}

// Eksempelbruk
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "Radiusen er %.2f enheter.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## Beregn radius fra diameter i celle B1
=IF(B1>0, B1/2, "Ugyldig inndata")

## Beregn radius fra omkrets i celle B2
=IF(B2>0, B2/(2*PI()), "Ugyldig inndata")

## Beregn radius fra areal i celle B3
=IF(B3>0, SQRT(B3/PI()), "Ugyldig inndata")

Visualisering

Et SVG-diagram som illustrerer forholdet mellom radius, diameter og omkrets:

Radius (r) Diameter (d) Omkrets (C)

Referanser

  1. Sirkel - Wikipedia
  2. Omkrets - Math Is Fun
  3. Areal av en Sirkel - Khan Academy
  4. Historien om (\pi) - Wikipedia
Feedback