C#-Code

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

namespace ConsoleMittlererPunktabstand
{
    class Program
    {
        static readonly Random rnd = new Random();
        static void Main(string[] args)
        {
            int iterations = 1000000;
            double maxWidth = 1;
            double maxHeight = 1;

            Stopwatch sw = new Stopwatch();
            sw.Start();
            Task<double> taskLineExperiment = Task.Factory.StartNew(() => LineExperiment(iterations, maxWidth));
            Task<double> taskSquareExperiment = Task.Factory.StartNew(() => SquareExperiment(iterations, maxWidth));
            Task<double> taskRectangleExperiment = Task.Factory.StartNew(() => RectangleExperiment(iterations, maxWidth, maxHeight));
            Task<double> taskCircleExperiment = Task.Factory.StartNew(() => CircleExperiment(iterations, maxWidth));
            Task<double> taskEllipseExperiment = Task.Factory.StartNew(() => EllipseExperiment(iterations, maxWidth, maxHeight));

            Task.WaitAll(taskLineExperiment, taskSquareExperiment, taskRectangleExperiment, taskCircleExperiment, taskEllipseExperiment);
            sw.Stop();


            Console.WriteLine($"{nameof(LineExperiment)}: {taskLineExperiment.Result}");
            Console.WriteLine($"{nameof(SquareExperiment)}: {taskSquareExperiment.Result}");
            Console.WriteLine($"{nameof(RectangleExperiment)}: {taskRectangleExperiment.Result}");
            Console.WriteLine($"{nameof(CircleExperiment)}: {taskCircleExperiment.Result}");
            Console.WriteLine($"{nameof(EllipseExperiment)}: {taskEllipseExperiment.Result}");
            Console.WriteLine($"Benötigte Zeit: {sw.Elapsed}");
            Console.ReadLine();
        }

        static double LineExperiment(int iterations, double maxWidth)
        {
            return CreateManyForms(EuclidianType.Line, iterations, maxWidth).Average(a => CalcDistance(a));
        }

        static double SquareExperiment(int iterations, double maxWidth)
        {
            return CreateManyForms(EuclidianType.Square, iterations, maxWidth).Average(a => CalcDistance(a));
        }

        static double RectangleExperiment(int iterations, double maxWidth, double maxHeight)
        {
            return CreateManyForms(EuclidianType.Rectangle, iterations, maxWidth, maxHeight).Average(a => CalcDistance(a));
        }

        static double CircleExperiment(int iterations, double maxWidth)
        {
            return CreateManyForms(EuclidianType.Circle, iterations, maxWidth).Average(a => CalcDistance(a));
        }

        static double EllipseExperiment(int iterations, double maxWidth, double maxHeight)
        {
            return CreateManyForms(EuclidianType.Ellipse, iterations, maxWidth, maxHeight).Average(a => CalcDistance(a));
        }

        static double CalcDistance(EuclidianForm form)
        {
            if (form != null)
            {
                Point first = form.GeneratePoint();
                Point second = form.GeneratePoint();

                Vector diff = second - first;

                return diff.Length / form.Umfang;
            }
            else
            {
                return double.NaN;
            }
        }

        static EuclidianForm CreateRandomForm(EuclidianType type, double maxWidth, double maxHeight = 0)
        {
            EuclidianForm form = new EuclidianForm();
            form.Type = type;
            lock (rnd)
            {
                double w = rnd.NextDouble();
                double h;
                form.Width = maxWidth * w;
                if (maxHeight != 0)
                {
                    h = rnd.NextDouble();
                    form.Height = maxHeight * h;
                }
            }
            return form;
        }

        static IEnumerable<EuclidianForm> CreateManyForms(EuclidianType type, int iterations, double maxWidth, double maxHeight = 0)
        {
            for (int i = 0; i < iterations; i++)
            {
                yield return CreateRandomForm(type, maxWidth, maxHeight);
            }
        }
    }

    class EuclidianForm
    {
        private static readonly Random rnd = new Random();

        public EuclidianType Type { get; set; }

        private double width = 1;
        public double Width
        {
            get { return width; }
            set
            {
                width = value;
                if (Type == EuclidianType.Circle || Type == EuclidianType.Square)
                { height = value; }
            }
        }

        private double height = 1;
        public double Height
        {
            get { return height; }
            set
            {
                if (Type != EuclidianType.Line)
                {
                    height = value;
                    if (Type == EuclidianType.Circle || Type == EuclidianType.Square)
                    { width = value; }
                }
            }
        }

        public double Umfang => calcUmfang();


        #region Erzeugen von zufälligen Punkten
        public Point GeneratePoint()
        {
            switch (Type)
            {
                case EuclidianType.Line:
                    return GeneratePointLine();

                case EuclidianType.Square:
                    return GeneratePointSquare();

                case EuclidianType.Rectangle:
                    return GeneratePointRectangle();

                case EuclidianType.Circle:
                    return GeneratePointCircle();

                case EuclidianType.Ellipse:
                    return GeneratePointEllipse();

                default:
                    throw new ArgumentException();
            }
        }

        private Point GeneratePointLine()
        {
            Point p = new Point();
            lock (rnd)
            {
                p.X = Width * rnd.NextDouble();
                p.Y = 0;
            }
            return p;
        }

        private Point GeneratePointSquare()
        {
            Point p = new Point();
            lock (rnd)
            {
                p.X = Width * rnd.NextDouble();
                p.Y = Width * rnd.NextDouble();
            }
            return p;
        }

        private Point GeneratePointRectangle()
        {
            Point p = new Point();
            lock (rnd)
            {
                p.X = Width * rnd.NextDouble();
                p.Y = Height * rnd.NextDouble();
            }
            return p;
        }

        private Point GeneratePointCircle()
        {
            Point p = new Point();
            lock (rnd)
            {
                double radius = Width / 2;

                double x = rnd.NextDouble() * Width - radius;

                double maxY = Math.Sqrt(radius * radius - x * x);
                double minY = -maxY;

                double y = (maxY - minY) * rnd.NextDouble() + minY;

                p.X = x;
                p.Y = y;
            }

            return p;
        }

        private Point GeneratePointEllipse()
        {
            Point p = new Point();

            lock (rnd)
            {
                double a = Width / 2;
                double b = Height / 2;

                double x = rnd.NextDouble() * Width - a;
                double maxY = Math.Sqrt((b * b) - ((b * b) / (a * a)) * (x * x));

                double minY = -maxY;

                double y = (maxY - minY) * rnd.NextDouble() + minY;

                p.X = x;
                p.Y = y;
            }

            return p;
        }
        #endregion

        private double calcUmfang()
        {
            switch (Type)
            {
                case EuclidianType.Line:
                    return 2 * Width;

                case EuclidianType.Square:
                    return 4 * Width;

                case EuclidianType.Rectangle:
                    return 2 * Width + 2 * Height;

                case EuclidianType.Circle:
                    return Math.PI * Width;

                case EuclidianType.Ellipse:
                    //Näherungsformel nach Ramanujan
                    double a = Width / 2;
                    double b = Height / 2;
                    double l = Math.Pow(((a - b) / (a + b)), 2) * 3;
                    return Math.PI * (a + b) * (1 + (l / (10 + Math.Sqrt(4 - l))));

                default:
                    return double.NaN;
            }
        }


    }

    class Point
    {
        public double X { get; set; }
        public double Y { get; set; }

        public static Vector operator +(Point left, Point right) => new Vector() { X = left.X + right.X, Y = left.Y + right.Y };
        public static Vector operator -(Point left, Point right) => new Vector() { X = left.X - right.X, Y = left.Y - right.Y };
    }

    class Vector : Point
    {
        public double Length => Math.Sqrt(X * X + Y * Y);
    }

    enum EuclidianType
    {
        Line, Square, Rectangle, Circle, Ellipse
    }
}