## வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
def radius_from_diameter(diameter):
    if diameter <= 0:
        raise ValueError("வட்டக்கோடு பூமிக்கு மேலாக இருக்க வேண்டும்.")
    return diameter / 2

## எடுத்துக்காட்டு பயன்பாடு
d = 10
r = radius_from_diameter(d)
print(f"ஆரம் {r} அலகுகள்.")

// வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
function radiusFromDiameter(diameter) {
    if (diameter <= 0) {
        throw new Error("வட்டக்கோடு பூமிக்கு மேலாக இருக்க வேண்டும்.");
    }
    return diameter / 2;
}

// எடுத்துக்காட்டு பயன்பாடு
let d = 10;
let r = radiusFromDiameter(d);
console.log(`ஆரம் ${r} அலகுகள்.`);

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);
    }
}

// வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
#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;
}

## வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
radius_from_diameter <- function(diameter) {
  if (diameter <= 0) {
    stop("வட்டக்கோடு பூமிக்கு மேலாக இருக்க வேண்டும்.")
  }
  return(diameter / 2)
}

## எடுத்துக்காட்டு பயன்பாடு
d <- 10
r <- radius_from_diameter(d)
cat(sprintf("ஆரம் %.2f அலகுகள்.\n", r))

## வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
def radius_from_diameter(diameter)
  raise ArgumentError, "வட்டக்கோடு பூமிக்கு மேலாக இருக்க வேண்டும்." if diameter <= 0
  diameter / 2.0
end

## எடுத்துக்காட்டு பயன்பாடு
d = 10
r = radius_from_diameter(d)
puts "ஆரம் #{r} அலகுகள்."

<?php
// வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
function radiusFromDiameter($diameter) {
    if ($diameter <= 0) {
        throw new Exception('வட்டக்கோடு பூமிக்கு மேலாக இருக்க வேண்டும்.');
    }
    return $diameter / 2;
}

// எடுத்துக்காட்டு பயன்பாடு
$d = 10;
$r = radiusFromDiameter($d);
echo "ஆரம் {$r} அலகுகள்.";
?>

// வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
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),
    }
}

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)
}

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} அலகுகள்.")

// சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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)} அலகுகள்.`);

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);
    }
}

// சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
#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;
}

## சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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))

## சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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
// சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
function radiusFromCircumference($circumference) {
    if ($circumference <= 0) {
        throw new Exception('சுற்றளவு பூமிக்கு மேலாக இருக்க வேண்டும்.');
    }
    return $circumference / (2 * M_PI);
}

// எடுத்துக்காட்டு பயன்பாடு
$C = 31.4159;
$r = radiusFromCircumference($C);
echo "ஆரம் " . round($r, 2) . " அலகுகள்.";
?>

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),
    }
}

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)
}

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} அலகுகள்.")

// பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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)} அலகுகள்.`);

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);
    }
}

// பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
#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;
}

## பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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))

% பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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);

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);
    }
}

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)
}

## பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
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
// பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
function radiusFromArea($area) {
    if ($area <= 0) {
        throw new Exception('பரப்பளவு பூமிக்கு மேலாக இருக்க வேண்டும்.');
    }
    return sqrt($area / M_PI);
}

// எடுத்துக்காட்டு பயன்பாடு
$A = 78.5398;
$r = radiusFromArea($A);
echo "ஆரம் " . round($r, 2) . " அலகுகள்.";
?>

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),
    }
}

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)
}

## B1 செலில் வட்டக்கோடிலிருந்து ஆரத்தை கணக்கிடுதல்
=IF(B1>0, B1/2, "செல்லுபடியாகாத உள்ளீடு")

## B2 செலில் சுற்றளவிலிருந்து ஆரத்தை கணக்கிடுதல்
=IF(B2>0, B2/(2*PI()), "செல்லுபடியாகாத உள்ளீடு")

## B3 செலில் பரப்பளவிலிருந்து ஆரத்தை கணக்கிடுதல்
=IF(B3>0, SQRT(B3/PI()), "செல்லுபடியாகாத உள்ளீடு")