• D

auto c = tuple((x1+x2)/2, (y1+y2)/2);

• Clojure

(defn c 
  "calculates the center c of a rectangle of coordinates(x1, y1, x2, y2)" 
  [x1 y1 x2 y2]
  {:x (/ (+ x1 x2) 2)
   :y (/ (+ y1 y2) 2)})

• C++

template <typename T> struct Point {
  T x = {};
  T y = {};
};
template <typename T> struct Rectangle {
  Point<T> upper_left;
  Point<T> lower_right;
};
template <typename T>
Point<T> get_center(const Rectangle<T>& rect) {
  return {
    .x = (rect.upper_left.x + rect.lower_right.x) / 2,
    .y = (rect.upper_left.y + rect.lower_right.y) / 2,
  };
}

• C#

class Point
{
	public float X { get; }
	public float Y { get; }

	public Point(float x, float y)
	{
		X = x;
		Y = y;
	}
}

class Rectangle
{
	Point Point1;
	Point Point2;

	public Rectangle(Point point1, Point point2)
	{
		Point1 = point1;
		Point2 = point2;
	}

	public Point GetCenter()
	{
		return new Point(
		(Point1.X + Point2.X) / 2,
		(Point1.Y + Point2.Y) / 2
		);
	}
}

• Dart

var r = MutableRectangle.fromPoints(Point(x1, y1), Point(x2, y2));
var center = Point(r.width / 2, r.height / 2);

• Fortran

real :: center(2)
center = [(x1 + x2)/2, (y1 + y2)/2]

• Go

c := image.Pt((x1+x2)/2, (y1+y2)/2)

• Haskell

rectCenter :: Num a => (a, a) -> (a, a) -> (a,a)
rectCenter (x1,y1) (x2,y2) = ((x1+x2)/2,(y1+y2)/2)

• JS

class Point {
  constructor (x, y) {
    this.x = x
    this.y = y
  }
}
const center = ({x1, y1, x2, y2}) => new Point ((x1 + x2) / 2, (y1 + y2) / 2)

• JS

const center = ({x1, y1, x2, y2}) => ({x: (x1 + x2) / 2, y: (y1 + y2) / 2})

• Java

double w = x2 - x1, h = y2 - y1;
Rectangle2D r = new Rectangle2D.Double(x1, y1, w, h);
double c[] = { r.getCenterX(), r.getCenterY() };

• Java

int w = x2 - x1, h = y2 - y1;
Rectangle r = new Rectangle(x1, y1, w, h);
double c[] = { r.getCenterX(), r.getCenterY() };

• Java

double[] c = {(x1+x2)/2,(y1+y2)/2};

• Kotlin

data class Point(val x: Double, val y: Double)
data class Rectangle(val x1: Double, val y1: Double, val x2: Double, val y2: Double){
  fun center() = Point( x = (x1 + x2)/2, y =(y1 + y2)/2)
}

• Kotlin

fun center(x1: int, y1: int, x2: int, y2: int) = Pair((x1 + x2)/2, (y1 + y2)/2)

• PHP

class Point
{
	public $x;
	public $y;

	public function __construct(float x, float y)
	{
		$this->x = x;
		$this->y = y;
	}
}

class Rectangle
{
	private $point1;
	private $point2;

	public function __construct(Point $point1, Point $point2)
	{
		$this->point1 = $point1;
		$this->point2 = $point2;
	}

	public function getCenter(): Point
	{
		return new Point(
			($this->point1->x + $this->point2->x) / 2,
			($this->point1->y + $this->point2->y) / 2
		);
	}
}

• Pascal

c := CenterPoint(Rect(x1,y1,x2,y2));

• Perl

my @c = (($x1 + $x2) / 2, ($y1 + $y2) / 2);

• Python

Point = namedtuple('Point', 'x y')
center = Point((x1+x2)/2, (y1+y2)/2)

• Python

center = ((x1+x2)/2, (y1+y2)/2)

• Python

class Rectangle:
    def __init__(self, x, y, w, h):
        self.x, self.y = x, y
        self.w, self.h = w, h
    def center(self):
        return {
            'x': (self.x + self.w) / 2,
            'y': (self.y + self.h) / 2
        }
w, h = x2 - x1, y2 - y1
r = Rectangle(x1, y1, w, h)
c = r.center()

• Ruby

Point = Struct.new(:x, :y)

Rect  = Struct.new(:x1, :y1, :x2, :y2) do
  def center  
    Point.new((x1+x2)/2.0, (y1+y2)/2.0)
  end
end

c = Rect.new(0,0,2,5).center

• Rust

struct Rectangle {
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64,
}

impl Rectangle {
    pub fn center(&self) -> (f64, f64) {
	    ((self.x1 + self.x2) / 2.0, (self.y1 + self.y2) / 2.0)
    }
}

• Smalltalk

c := (x1@y1 corner: x1@y2) center.