Calcolatore del Raggio di un Cerchio per Geometria

Calcolatore del Raggio di un Cerchio

Introduzione

Il raggio di un cerchio è una delle sue proprietà più fondamentali. È la distanza dal centro del cerchio a qualsiasi punto sulla sua circonferenza. Questo calcolatore consente di determinare il raggio di un cerchio basato su tre diversi parametri di input:

Diametro
Circonferenza
Area

Fornendo uno di questi valori, puoi calcolare il raggio utilizzando le relazioni matematiche insite nella geometria del cerchio.

Formula

Il raggio può essere calcolato dal diametro, dalla circonferenza o dall'area utilizzando le seguenti formule:

Dal Diametro ( $d$ ):
$r = \frac{d}{2}$
Dalla Circonferenza ( $C$ ):
$r = \frac{C}{2\pi}$
Dall'Area ( $A$ ):
$r = \sqrt{\frac{A}{\pi}}$

Queste formule sono derivate dalle proprietà di base di un cerchio:

Diametro: Il diametro è il doppio del raggio ( $d = 2r$ ).
Circonferenza: La circonferenza è la distanza attorno al cerchio ( $C = 2\pi r$ ).
Area: L'area racchiusa dal cerchio ( $A = \pi r^2$ ).

Calcolo

Calcolo del Raggio dal Diametro

Dato il diametro, il raggio è semplicemente la metà di esso:

r = \frac{d}{2}

Esempio:

Se il diametro è di 10 unità:

r = \frac{10}{2} = 5 \text{ unità}

Calcolo del Raggio dalla Circonferenza

Partendo dalla formula della circonferenza:

C = 2\pi r

Risolvendo per $r$ :

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

Esempio:

Se la circonferenza è di $31.4159$ unità:

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

Calcolo del Raggio dall'Area

Partendo dalla formula dell'area:

A = \pi r^2

Risolvendo per $r$ :

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

Esempio:

Se l'area è di $78.5398$ unità quadrate:

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

Casi Limite e Validazione degli Input

Input Zero o Negativi: Un cerchio non può avere un diametro, una circonferenza o un'area negativi o nulli. Se uno di questi valori è zero o negativo, il raggio è indefinito. Il calcolatore mostrerà un messaggio di errore in tali casi.
Input Non Numerici: Il calcolatore richiede input numerici. Valori non numerici (ad es. lettere o simboli) sono non validi.

Precisione e Arrotondamento

Questo calcolatore utilizza l'aritmetica in virgola mobile a doppia precisione per i calcoli. I risultati sono generalmente visualizzati arrotondati a quattro decimali per una maggiore accuratezza. Quando si utilizzano costanti matematiche come $\pi$ , il calcolatore utilizza la massima precisione disponibile nel linguaggio di programmazione o nell'ambiente. Tieni presente che l'aritmetica in virgola mobile può introdurre piccoli errori di arrotondamento in alcuni casi.

Casi d'Uso

Calcolare il raggio di un cerchio è essenziale in vari campi:

Ingegneria e Costruzione

Progettazione di Componenti Circolari: Gli ingegneri spesso devono determinare il raggio quando progettano ruote, ingranaggi, tubi o cupole.
Architettura: Gli architetti utilizzano il raggio per progettare archi, cupole e edifici circolari.

Astronomia

Orbite Planetarie: Gli astronomi calcolano il raggio delle orbite planetarie basandosi su dati osservativi.
Corpi Celesti: Determinazione delle dimensioni di pianeti, stelle e altri oggetti celesti.

Risoluzione di Problemi Quotidiani

Arte e Design: Artisti e designer calcolano il raggio per creare motivi e design circolari.
Progetti Fai-da-te: Calcolo dei materiali necessari per tavoli, giardini o fontane circolari.

Matematica ed Educazione

Apprendimento della Geometria: Comprendere le proprietà dei cerchi è fondamentale nell'educazione geometrica.
Risoluzione di Problemi: I calcoli del raggio sono comuni nei problemi matematici e nelle competizioni.

Alternative

Sebbene il raggio sia una proprietà primaria, a volte altre proprietà del cerchio sono più convenienti da misurare direttamente:

Misurazione della Lunghezza del Cordone: Utile quando si hanno punti fissi su un cerchio e si deve calcolare il raggio.
Utilizzo dell'Area del Settore o della Lunghezza dell'Arco: Nei casi che coinvolgono sezioni parziali di un cerchio.

Storia

Lo studio dei cerchi risale alle antiche civiltà:

Geometria Antica: Il cerchio è stato studiato fin dai tempi degli antichi egizi e babilonesi.
Elementi di Euclide: Intorno al 300 a.C., Euclide definì il cerchio e le sue proprietà nella sua opera fondamentale, Elementi.
Archimede: Fornì metodi per approssimare (\pi) e calcolò aree e volumi relativi a cerchi e sfere.
Sviluppo di (\pi): Nel corso dei secoli, matematici come Liu Hui, Zu Chongzhi, Aryabhata e infine John Wallis e Isaac Newton hanno affinato il valore e la comprensione di (\pi).

Il raggio rimane un concetto fondamentale non solo in geometria ma anche in fisica, ingegneria e varie scienze applicate.

Esempi

Ecco esempi di codice in più linguaggi di programmazione per calcolare il raggio dal diametro, dalla circonferenza e dall'area.

Dal Diametro

Python

## Calcola il raggio dal diametro
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("Il diametro deve essere maggiore di zero.")
    return diameter / 2

## Esempio di utilizzo
d = 10
r = radius_from_diameter(d)
print(f"Il raggio è {r} unità.")

JavaScript

// Calcola il raggio dal diametro
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("Il diametro deve essere maggiore di zero.");
    }
    return diameter / 2;
}

// Esempio di utilizzo
let d = 10;
let r = radiusFromDiameter(d);
console.log(`Il raggio è ${r} unità.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("Il diametro deve essere maggiore di zero.");
        }
        return diameter / 2;
    }

    public static void main(String[] args) {
        double d = 10;
        double r = radiusFromDiameter(d);
        System.out.printf("Il raggio è %.2f unità.%n", r);
    }
}

C++

// Calcola il raggio dal diametro
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("Il diametro deve essere maggiore di zero.");
    }
    return diameter / 2.0;
}

int main() {
    double d = 10.0;
    try {
        double r = radiusFromDiameter(d);
        std::cout << "Il raggio è " << r << " unità." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Calcola il raggio dal diametro
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("Il diametro deve essere maggiore di zero.")
  }
  return(diameter / 2)
}

## Esempio di utilizzo
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("Il raggio è %.2f unità.\n", r))

Ruby

## Calcola il raggio dal diametro
def radius_from_diameter(diameter)
  raise ArgumentError, "Il diametro deve essere maggiore di zero." if diameter <= 0
  diameter / 2.0
end

## Esempio di utilizzo
d = 10
r = radius_from_diameter(d)
puts "Il raggio è #{r} unità."

PHP

<?php
// Calcola il raggio dal diametro
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('Il diametro deve essere maggiore di zero.');
    }
    return $diameter / 2;
}

// Esempio di utilizzo
$d = 10;
$r = radiusFromDiameter($d);
echo "Il raggio è {$r} unità.";
?>

Rust

// Calcola il raggio dal diametro
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("Il diametro deve essere maggiore di zero.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("Il raggio è {:.2} unità.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Calcola il raggio dal diametro
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "Il diametro deve essere maggiore di zero."])
    }
    return diameter / 2.0
}

// Esempio di utilizzo
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("Il raggio è \(r) unità.")
} catch {
    print(error.localizedDescription)
}

Dalla Circonferenza

Python

import math

## Calcola il raggio dalla circonferenza
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("La circonferenza deve essere maggiore di zero.")
    return circumference / (2 * math.pi)

## Esempio di utilizzo
C = 31.4159
r = radius_from_circumference(C)
print(f"Il raggio è {r:.2f} unità.")

JavaScript

// Calcola il raggio dalla circonferenza
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("La circonferenza deve essere maggiore di zero.");
    }
    return circumference / (2 * Math.PI);
}

// Esempio di utilizzo
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`Il raggio è ${r.toFixed(2)} unità.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("La circonferenza deve essere maggiore di zero.");
        }
        return circumference / (2 * Math.PI);
    }

    public static void main(String[] args) {
        double C = 31.4159;
        double r = radiusFromCircumference(C);
        System.out.printf("Il raggio è %.2f unità.%n", r);
    }
}

C++

// Calcola il raggio dalla circonferenza
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("La circonferenza deve essere maggiore di zero.");
    }
    return circumference / (2.0 * M_PI);
}

int main() {
    double C = 31.4159;
    try {
        double r = radiusFromCircumference(C);
        std::cout << "Il raggio è " << r << " unità." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Calcola il raggio dalla circonferenza
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("La circonferenza deve essere maggiore di zero.")
  }
  return(circumference / (2 * pi))
}

## Esempio di utilizzo
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("Il raggio è %.2f unità.\n", r))

Ruby

## Calcola il raggio dalla circonferenza
def radius_from_circumference(circumference)
  raise ArgumentError, "La circonferenza deve essere maggiore di zero." if circumference <= 0
  circumference / (2 * Math::PI)
end

## Esempio di utilizzo
C = 31.4159
r = radius_from_circumference(C)
puts "Il raggio è #{format('%.2f', r)} unità."

PHP

<?php
// Calcola il raggio dalla circonferenza
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('La circonferenza deve essere maggiore di zero.');
    }
    return $circumference / (2 * M_PI);
}

// Esempio di utilizzo
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "Il raggio è " . round($r, 2) . " unità.";
?>

Rust

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

// Calcola il raggio dalla circonferenza
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("La circonferenza deve essere maggiore di zero.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("Il raggio è {:.2} unità.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Calcola il raggio dalla circonferenza
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "La circonferenza deve essere maggiore di zero."])
    }
    return circumference / (2 * Double.pi)
}

// Esempio di utilizzo
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "Il raggio è %.2f unità.", r))
} catch {
    print(error.localizedDescription)
}

Dall'Area

Python

import math

## Calcola il raggio dall'area
def radius_from_area(area):
    if area <= 0:
        raise ValueError("L'area deve essere maggiore di zero.")
    return math.sqrt(area / math.pi)

## Esempio di utilizzo
A = 78.5398
r = radius_from_area(A)
print(f"Il raggio è {r:.2f} unità.")

JavaScript

// Calcola il raggio dall'area
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("L'area deve essere maggiore di zero.");
    }
    return Math.sqrt(area / Math.PI);
}

// Esempio di utilizzo
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`Il raggio è ${r.toFixed(2)} unità.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("L'area deve essere maggiore di zero.");
        }
        return Math.sqrt(area / Math.PI);
    }

    public static void main(String[] args) {
        double A = 78.5398;
        double r = radiusFromArea(A);
        System.out.printf("Il raggio è %.2f unità.%n", r);
    }
}

C++

// Calcola il raggio dall'area
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("L'area deve essere maggiore di zero.");
    }
    return std::sqrt(area / M_PI);
}

int main() {
    double A = 78.5398;
    try {
        double r = radiusFromArea(A);
        std::cout << "Il raggio è " << r << " unità." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## Calcola il raggio dall'area
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("L'area deve essere maggiore di zero.")
  }
  return(sqrt(area / pi))
}

## Esempio di utilizzo
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("Il raggio è %.2f unità.\n", r))

MATLAB

% Calcola il raggio dall'area
function r = radius_from_area(area)
    if area <= 0
        error('L''area deve essere maggiore di zero.');
    end
    r = sqrt(area / pi);
end

% Esempio di utilizzo
A = 78.5398;
r = radius_from_area(A);
fprintf('Il raggio è %.2f unità.\n', r);

C#

using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("L'area deve essere maggiore di zero.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("Il raggio è {0:F2} unità.", r);
    }
}

Go

package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("L'area deve essere maggiore di zero.")
	}
	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("Il raggio è %.2f unità.\n", r)
}

Ruby

## Calcola il raggio dall'area
def radius_from_area(area)
  raise ArgumentError, "L'area deve essere maggiore di zero." if area <= 0
  Math.sqrt(area / Math::PI)
end

## Esempio di utilizzo
A = 78.5398
r = radius_from_area(A)
puts "Il raggio è #{format('%.2f', r)} unità."

PHP

<?php
// Calcola il raggio dall'area
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('L''area deve essere maggiore di zero.');
    }
    return sqrt($area / M_PI);
}

// Esempio di utilizzo
$A = 78.5398;
$r = radiusFromArea($A);
echo "Il raggio è " . round($r, 2) . " unità.";
?>

Rust

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

// Calcola il raggio dall'area
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("L'area deve essere maggiore di zero.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("Il raggio è {:.2} unità.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// Calcola il raggio dall'area
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "L'area deve essere maggiore di zero."])
    }
    return sqrt(area / Double.pi)
}

// Esempio di utilizzo
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "Il raggio è %.2f unità.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## Calcola il raggio dal diametro nella cella B1
=IF(B1>0, B1/2, "Input non valido")

## Calcola il raggio dalla circonferenza nella cella B2
=IF(B2>0, B2/(2*PI()), "Input non valido")

## Calcola il raggio dall'area nella cella B3
=IF(B3>0, SQRT(B3/PI()), "Input non valido")

Visualizzazione

Un diagramma SVG che illustra la relazione tra il raggio, il diametro e la circonferenza:

Riferimenti

Cerchio - Wikipedia
Circonferenza - Math Is Fun
Area di un Cerchio - Khan Academy
Storia di (\pi) - Wikipedia

Strumenti correlati

Calcolatore per Coni Circolari Retti e le loro Misurazioni

Calcolatore del Diametro del Cono per Geometria e Ingegneria

Calcolatore delle Misure del Cerchio e delle Proprietà