מחשבון חישוב רדיוס מעגל מדויק וקל לשימוש

מחשבון רדיוס מעגל

הקדמה

הרדיוס של מעגל הוא אחת התכונות הבסיסיות שלו. זהו המרחק ממרכז המעגל לכל נקודה על היקף שלו. מחשבון זה מאפשר לך לקבוע את הרדיוס של מעגל על סמך שלושה פרמטרים שונים:

קוטר
היקף
שטח

על ידי מתן ערך אחד מתוך אלה, תוכל לחשב את הרדיוס באמצעות הקשרים המתמטיים הקיימים בגיאומטריה של מעגל.

נוסחה

הרדיוס יכול להיות מחושב מהקוטר, ההיקף או השטח באמצעות הנוסחאות הבאות:

מהקוטר ( $d$ ):
$r = \frac{d}{2}$
מההיקף ( $C$ ):
$r = \frac{C}{2\pi}$
מהשטח ( $A$ ):
$r = \sqrt{\frac{A}{\pi}}$

נוסחאות אלו נגזרות מהתכונות הבסיסיות של מעגל:

קוטר: הקוטר הוא כפול הרדיוס ( $d = 2r$ ).
היקף: ההיקף הוא המרחק סביב המעגל ( $C = 2\pi r$ ).
שטח: השטח הכלוא על ידי המעגל ( $A = \pi r^2$ ).

חישוב

חישוב רדיוס מהקוטר

בהינתן הקוטר, הרדיוס הוא פשוט חצי ממנו:

r = \frac{d}{2}

דוגמה:

אם הקוטר הוא 10 יחידות:

r = \frac{10}{2} = 5 \text{ יחידות}

חישוב רדיוס מההיקף

מתחילים עם נוסחת ההיקף:

C = 2\pi r

פתרון עבור $r$ :

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

דוגמה:

אם ההיקף הוא $31.4159$ יחידות:

r = \frac{31.4159}{2\pi} \approx \frac{31.4159}{6.2832} \approx 5 \text{ יחידות}

חישוב רדיוס מהשטח

מתחילים עם נוסחת השטח:

A = \pi r^2

פתרון עבור $r$ :

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

דוגמה:

אם השטח הוא $78.5398$ יחידות ריבועיות:

r = \sqrt{\frac{78.5398}{\pi}} = \sqrt{\frac{78.5398}{3.1416}} \approx \sqrt{25} = 5 \text{ יחידות}

מקרים קצה ואימות קלט

קלטים אפסיים או שליליים: למעגל לא יכול להיות קוטר, היקף או שטח שליליים או אפסיים. אם אחד מהערכים הללו הוא אפס או שלילי, הרדיוס אינו מוגדר. המחשבון יציג הודעת שגיאה במקרים כאלה.
קלטים לא מספריים: המחשבון דורש קלטים מספריים. ערכים לא מספריים (למשל, אותיות או סמלים) אינם תקפים.

דיוק ועיגול

מחשבון זה משתמש באריתמטיקה של נקודות צף כפולות לדיוק בחישובים. התוצאות מוצגות בדרך כלל מעוגלות לארבע ספרות אחרי הנקודה כדי להבטיח דיוק גבוה יותר. כאשר משתמשים בקבועים מתמטיים כמו $\pi$ , המחשבון מנצל את כל הדיוק הזמין בשפת התכנות או בסביבה. יש להיות מודעים לכך שאריתמטיקת נקודות צף יכולה להכניס שגיאות עיגול קטנות בכמה מקרים.

שימושים

חישוב הרדיוס של מעגל הוא חיוני בתחומים שונים:

הנדסה ובנייה

עיצוב רכיבים מעגליים: מהנדסים לעיתים קרובות צריכים לקבוע את הרדיוס כאשר הם מעצבים גלגלים, גלגלי שיניים, צינורות או כיפות.
אדריכלות: אדריכלים משתמשים ברדיוס כדי לעצב קשתות, כיפות ובניינים מעגליים.

אסטרונומיה

מסלולי כוכבי לכת: אסטרונומים מחשבים את הרדיוס של מסלולי כוכבי לכת על סמך נתוני תצפית.
גופים שמימיים: קביעת הגדלים של כוכבי לכת, כוכבים וגופים שמימיים אחרים.

פתרון בעיות יומיומיות

אמנות ועיצוב: אמנים ומעצבים מחשבים את הרדיוס כדי ליצור דפוסים ועיצובים מעגליים.
פרויקטים של DIY: חישוב החומרים הנדרשים עבור שולחנות מעגליים, גינות או מזרקות.

מתמטיקה וחינוך

למידת גיאומטריה: הבנת התכונות של מעגלים היא בסיסית בחינוך גיאומטרי.
פתרון בעיות: חישובי רדיוס נפוצים בבעיות מתמטיות ובתחרויות.

חלופות

בעוד שהרדיוס הוא תכונה עיקרית, לפעמים תכונות אחרות של המעגל נוחות יותר למדידה ישירה:

מדידת אורך הקשת: מועיל כאשר יש לך נקודות קבועות על מעגל ואתה צריך לחשב את הרדיוס.
שימוש בשטח מגזר או אורך קשת: במקרים המעורבים בחלקים חלקיים של מעגל.

היסטוריה

המחקר של מעגלים מתחיל באזרחויות עתיקות:

גיאומטריה עתיקה: המעגל נלמד מאז ימי המצרים והבבלים.
אלמנטים של אוקלידס: בסביבות 300 לפני הספירה, אוקלידס הגדר את המעגל ואת תכונותיו בעבודתו המפורסמת, אלמנטים.
ארכימדס: סיפק שיטות להעריך את (\pi) וחישב שטחים ונפחים הקשורים למעגלים ולכדורים.
התפתחות של (\pi): במשך מאות שנים, מתמטיקאים כמו ליו הוי, זו צ'ונגז'י, אריאבהאטה, ולבסוף ג'ון ווליס ואייזק ניוטון שיפרו את הערך וההבנה של (\pi).

הרדיוס נשאר מושג בסיסי לא רק בגיאומטריה אלא גם ברחבי הפיזיקה, ההנדסה ומדעים יישומיים שונים.

דוגמאות

הנה דוגמאות קוד בשפות תכנות שונות כדי לחשב את הרדיוס מהקוטר, ההיקף והשטח.

מהקוטר

Python

## חישוב רדיוס מהקוטר
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("הקוטר חייב להיות גדול מאפס.")
    return diameter / 2

## דוגמת שימוש
d = 10
r = radius_from_diameter(d)
print(f"הרדיוס הוא {r} יחידות.")

JavaScript

// חישוב רדיוס מהקוטר
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("הקוטר חייב להיות גדול מאפס.");
    }
    return diameter / 2;
}

// דוגמת שימוש
let d = 10;
let r = radiusFromDiameter(d);
console.log(`הרדיוס הוא ${r} יחידות.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromDiameter(double diameter) {
        if (diameter <= 0) {
            throw new IllegalArgumentException("הקוטר חייב להיות גדול מאפס.");
        }
        return diameter / 2;
    }

    public static void main(String[] args) {
        double d = 10;
        double r = radiusFromDiameter(d);
        System.out.printf("הרדיוס הוא %.2f יחידות.%n", r);
    }
}

C++

// חישוב רדיוס מהקוטר
#include <iostream>
#include <stdexcept>

double radiusFromDiameter(double diameter) {
    if (diameter <= 0) {
        throw std::invalid_argument("הקוטר חייב להיות גדול מאפס.");
    }
    return diameter / 2.0;
}

int main() {
    double d = 10.0;
    try {
        double r = radiusFromDiameter(d);
        std::cout << "הרדיוס הוא " << r << " יחידות." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## חישוב רדיוס מהקוטר
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("הקוטר חייב להיות גדול מאפס.")
  }
  return(diameter / 2)
}

## דוגמת שימוש
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("הרדיוס הוא %.2f יחידות.\n", r))

Ruby

## חישוב רדיוס מהקוטר
def radius_from_diameter(diameter)
  raise ArgumentError, "הקוטר חייב להיות גדול מאפס." if diameter <= 0
  diameter / 2.0
end

## דוגמת שימוש
d = 10
r = radius_from_diameter(d)
puts "הרדיוס הוא #{r} יחידות."

PHP

<?php
// חישוב רדיוס מהקוטר
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('הקוטר חייב להיות גדול מאפס.');
    }
    return $diameter / 2;
}

// דוגמת שימוש
$d = 10;
$r = radiusFromDiameter($d);
echo "הרדיוס הוא {$r} יחידות.";
?>

Rust

// חישוב רדיוס מהקוטר
fn radius_from_diameter(diameter: f64) -> Result<f64, &'static str> {
    if diameter <= 0.0 {
        return Err("הקוטר חייב להיות גדול מאפס.");
    }
    Ok(diameter / 2.0)
}

fn main() {
    let d = 10.0;
    match radius_from_diameter(d) {
        Ok(r) => println!("הרדיוס הוא {:.2} יחידות.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// חישוב רדיוס מהקוטר
func radiusFromDiameter(_ diameter: Double) throws -> Double {
    if diameter <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "הקוטר חייב להיות גדול מאפס."])
    }
    return diameter / 2.0
}

// דוגמת שימוש
do {
    let d = 10.0
    let r = try radiusFromDiameter(d)
    print("הרדיוס הוא \(r) יחידות.")
} catch {
    print(error.localizedDescription)
}

מההיקף

Python

import math

## חישוב רדיוס מההיקף
def radius_from_circumference(circumference):
    if circumference <= 0:
        raise ValueError("ההיקף חייב להיות גדול מאפס.")
    return circumference / (2 * math.pi)

## דוגמת שימוש
C = 31.4159
r = radius_from_circumference(C)
print(f"הרדיוס הוא {r:.2f} יחידות.")

JavaScript

// חישוב רדיוס מההיקף
function radiusFromCircumference(circumference) {
    if (circumference <= 0) {
        throw new Error("ההיקף חייב להיות גדול מאפס.");
    }
    return circumference / (2 * Math.PI);
}

// דוגמת שימוש
let C = 31.4159;
let r = radiusFromCircumference(C);
console.log(`הרדיוס הוא ${r.toFixed(2)} יחידות.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromCircumference(double circumference) {
        if (circumference <= 0) {
            throw new IllegalArgumentException("ההיקף חייב להיות גדול מאפס.");
        }
        return circumference / (2 * Math.PI);
    }

    public static void main(String[] args) {
        double C = 31.4159;
        double r = radiusFromCircumference(C);
        System.out.printf("הרדיוס הוא %.2f יחידות.%n", r);
    }
}

C++

// חישוב רדיוס מההיקף
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromCircumference(double circumference) {
    if (circumference <= 0) {
        throw std::invalid_argument("ההיקף חייב להיות גדול מאפס.");
    }
    return circumference / (2.0 * M_PI);
}

int main() {
    double C = 31.4159;
    try {
        double r = radiusFromCircumference(C);
        std::cout << "הרדיוס הוא " << r << " יחידות." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## חישוב רדיוס מההיקף
radius_from_circumference <- function(circumference) {
  if (circumference <= 0) {
    stop("ההיקף חייב להיות גדול מאפס.")
  }
  return(circumference / (2 * pi))
}

## דוגמת שימוש
C <- 31.4159
r <- radius_from_circumference(C)
cat(sprintf("הרדיוס הוא %.2f יחידות.\n", r))

Ruby

## חישוב רדיוס מההיקף
def radius_from_circumference(circumference)
  raise ArgumentError, "ההיקף חייב להיות גדול מאפס." if circumference <= 0
  circumference / (2 * Math::PI)
end

## דוגמת שימוש
C = 31.4159
r = radius_from_circumference(C)
puts "הרדיוס הוא #{format('%.2f', r)} יחידות."

PHP

<?php
// חישוב רדיוס מההיקף
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('ההיקף חייב להיות גדול מאפס.');
    }
    return $circumference / (2 * M_PI);
}

// דוגמת שימוש
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "הרדיוס הוא " . round($r, 2) . " יחידות.";
?>

Rust

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

// חישוב רדיוס מההיקף
fn radius_from_circumference(circumference: f64) -> Result<f64, &'static str> {
    if circumference <= 0.0 {
        return Err("ההיקף חייב להיות גדול מאפס.");
    }
    Ok(circumference / (2.0 * PI))
}

fn main() {
    let C = 31.4159;
    match radius_from_circumference(C) {
        Ok(r) => println!("הרדיוס הוא {:.2} יחידות.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// חישוב רדיוס מההיקף
func radiusFromCircumference(_ circumference: Double) throws -> Double {
    if circumference <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "ההיקף חייב להיות גדול מאפס."])
    }
    return circumference / (2 * Double.pi)
}

// דוגמת שימוש
do {
    let C = 31.4159
    let r = try radiusFromCircumference(C)
    print(String(format: "הרדיוס הוא %.2f יחידות.", r))
} catch {
    print(error.localizedDescription)
}

מהשטח

Python

import math

## חישוב רדיוס מהשטח
def radius_from_area(area):
    if area <= 0:
        raise ValueError("השטח חייב להיות גדול מאפס.")
    return math.sqrt(area / math.pi)

## דוגמת שימוש
A = 78.5398
r = radius_from_area(A)
print(f"הרדיוס הוא {r:.2f} יחידות.")

JavaScript

// חישוב רדיוס מהשטח
function radiusFromArea(area) {
    if (area <= 0) {
        throw new Error("השטח חייב להיות גדול מאפס.");
    }
    return Math.sqrt(area / Math.PI);
}

// דוגמת שימוש
let A = 78.5398;
let r = radiusFromArea(A);
console.log(`הרדיוס הוא ${r.toFixed(2)} יחידות.`);

Java

public class CircleRadiusCalculator {
    public static double radiusFromArea(double area) {
        if (area <= 0) {
            throw new IllegalArgumentException("השטח חייב להיות גדול מאפס.");
        }
        return Math.sqrt(area / Math.PI);
    }

    public static void main(String[] args) {
        double A = 78.5398;
        double r = radiusFromArea(A);
        System.out.printf("הרדיוס הוא %.2f יחידות.%n", r);
    }
}

C++

// חישוב רדיוס מהשטח
#include <iostream>
#include <cmath>
#include <stdexcept>

double radiusFromArea(double area) {
    if (area <= 0) {
        throw std::invalid_argument("השטח חייב להיות גדול מאפס.");
    }
    return std::sqrt(area / M_PI);
}

int main() {
    double A = 78.5398;
    try {
        double r = radiusFromArea(A);
        std::cout << "הרדיוס הוא " << r << " יחידות." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

R

## חישוב רדיוס מהשטח
radius_from_area <- function(area) {
  if (area <= 0) {
    stop("השטח חייב להיות גדול מאפס.")
  }
  return(sqrt(area / pi))
}

## דוגמת שימוש
A <- 78.5398
r <- radius_from_area(A)
cat(sprintf("הרדיוס הוא %.2f יחידות.\n", r))

MATLAB

% חישוב רדיוס מהשטח
function r = radius_from_area(area)
    if area <= 0
        error('השטח חייב להיות גדול מאפס.');
    end
    r = sqrt(area / pi);
end

% דוגמת שימוש
A = 78.5398;
r = radius_from_area(A);
fprintf('הרדיוס הוא %.2f יחידות.\n', r);

C#

using System;

class CircleRadiusCalculator
{
    public static double RadiusFromArea(double area)
    {
        if (area <= 0)
            throw new ArgumentException("השטח חייב להיות גדול מאפס.");
        return Math.Sqrt(area / Math.PI);
    }

    static void Main()
    {
        double A = 78.5398;
        double r = RadiusFromArea(A);
        Console.WriteLine("הרדיוס הוא {0:F2} יחידות.", r);
    }
}

Go

package main

import (
	"fmt"
	"math"
)

func radiusFromArea(area float64) (float64, error) {
	if area <= 0 {
		return 0, fmt.Errorf("השטח חייב להיות גדול מאפס.")
	}
	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("הרדיוס הוא %.2f יחידות.\n", r)
}

Ruby

## חישוב רדיוס מהשטח
def radius_from_area(area)
  raise ArgumentError, "השטח חייב להיות גדול מאפס." if area <= 0
  Math.sqrt(area / Math::PI)
end

## דוגמת שימוש
A = 78.5398
r = radius_from_area(A)
puts "הרדיוס הוא #{format('%.2f', r)} יחידות."

PHP

<?php
// חישוב רדיוס מהשטח
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('השטח חייב להיות גדול מאפס.');
    }
    return sqrt($area / M_PI);
}

// דוגמת שימוש
$A = 78.5398;
$r = radiusFromArea($A);
echo "הרדיוס הוא " . round($r, 2) . " יחידות.";
?>

Rust

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

// חישוב רדיוס מהשטח
fn radius_from_area(area: f64) -> Result<f64, &'static str> {
    if area <= 0.0 {
        return Err("השטח חייב להיות גדול מאפס.");
    }
    Ok((area / PI).sqrt())
}

fn main() {
    let A = 78.5398;
    match radius_from_area(A) {
        Ok(r) => println!("הרדיוס הוא {:.2} יחידות.", r),
        Err(e) => println!("{}", e),
    }
}

Swift

import Foundation

// חישוב רדיוס מהשטח
func radiusFromArea(_ area: Double) throws -> Double {
    if area <= 0 {
        throw NSError(domain: "InvalidInput", code: 0, userInfo: [NSLocalizedDescriptionKey: "השטח חייב להיות גדול מאפס."])
    }
    return sqrt(area / Double.pi)
}

// דוגמת שימוש
do {
    let A = 78.5398
    let r = try radiusFromArea(A)
    print(String(format: "הרדיוס הוא %.2f יחידות.", r))
} catch {
    print(error.localizedDescription)
}

Excel

## חישוב רדיוס מהקוטר בתא B1
=IF(B1>0, B1/2, "קלט לא תקף")

## חישוב רדיוס מההיקף בתא B2
=IF(B2>0, B2/(2*PI()), "קלט לא תקף")

## חישוב רדיוס מהשטח בתא B3
=IF(B3>0, SQRT(B3/PI()), "קלט לא תקף")

ויזואליזציה

איור SVG הממחיש את הקשר בין הרדיוס, הקוטר וההיקף:

הפניות

מעגל - ויקיפדיה
היקף - Math Is Fun
שטח של מעגל - Khan Academy
היסטוריה של (\pi) - ויקיפדיה

כלי קשורים

מחשבון שטח ונפח של חרוט מעגלי נכון

מחשבון לקוטר חרוט - חישוב גובה ורדיוס חרוט

מחשבון מדידות מעגלים: רדיוס, קוטר והיקף מעגלים