Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		cal()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func cal() {
	var x1, y1, x2, y2, x3, y3 float64
	fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)
	a := 2 * (x1 - x2)
	b := 2 * (y1 - y2)
	c := 2 * (x1 - x3)
	d := 2 * (y1 - y3)
	e := x1*x1 - x2*x2 + y1*y1 - y2*y2
	f := x1*x1 - x3*x3 + y1*y1 - y3*y3

	px := (d*e - b*f) / (a*d - b*c)
	py := (a*f - c*e) / (a*d - b*c)

	r := math.Sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py))
	fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
}

C++: #include <bits/stdc++.h>

using namespace std;

#define EPS (1e-10)

struct Point {
    double x, y;

    Point(){}
    Point(double x, double y) : x(x), y(y) {}

    Point operator + (const Point &p) const {
        return Point(x + p.x, y + p.y);
    }

    Point operator - (const Point &p) const {
        return Point(x - p.x, y - p.y);
    }
    
    Point operator * (const double &k) const {
        return Point(x * k, y * k);
    }
};

double dot(const Point &a, const Point &b)
{
    return a.x * b.x + a.y * b.y;
}

double norm(const Point &p)
{
    return dot(p, p);
} 

double abs(const Point &p)
{
    return sqrt(norm(p));
}

typedef vector<Point> Polygon;

struct Circle {
    Point p;
    double r;
    Circle(){}
    Circle(Point p, double r) : p(p), r(r) {}
};

Circle smallest_enclosing_circle(const Polygon &pg)
{    
    Point p(0, 0);
    int N = pg.size();
    for (int i = 0; i < (int)pg.size(); i++) {
	p = p + pg[i];
    }
    p = p * (1. / pg.size());
    double d = 0.5;
    for (int k = 1; k <= 30; k++) {
	for (int i = 0; i < 100; i++) {
	    int s = 0;
	    for (int j = 0; j < N; j++) {
		if (abs(pg[j] - p) > abs(pg[s] - p)) {
		    s = j;
		}
	    }
	    p = p + (pg[s] - p) * d;
	}
	d *= 0.5;
    }
    double r = 0;
    for (int i = 0; i < N; i++) {
	if (abs(pg[i] - p) > r) {
	    r = abs(pg[i] - p);
	}
    }
    return Circle(p, r);
}

double round(double x)
{
    x *= 1000;
    x = x + (x >= 0 ? 0.5 : -0.5);
    x = (int)x;
    return x / 1000;
}

int main()
{
    Polygon pg(3);
    int N;
    cin >> N;
    while (N--) {
        for (int i = 0; i < 3; i++) {
            cin >> pg[i].x >> pg[i].y;
        }
        auto c = smallest_enclosing_circle(pg);
        printf("%.3f %.3f %.3f\n", c.p.x, c.p.y, c.r);
    }
    return 0;
}

C++: /*Filename: aoj0010.cpp
 *Author: Mushiyo
 */

#include <stdio.h>
#include <iostream>
#include <cmath>

using namespace std;

struct Point {
	double x;
	double y;
};

double countDist(Point p1, Point p2) {
	double xDist = abs(p1.x - p2.x);
	double yDist = abs(p1.y - p2.y);

	return sqrt(xDist * xDist + yDist * yDist);
}

Point getCircumCircleCenter(Point p1, Point p2, Point p3) {
	Point bias = p1;

	// a, b & c for ax + by = c
	double a1 = p2.x - p1.x, b1 = p2.y - p1.y, c1 = (a1 * a1 + b1 * b1) / 2;
	double a2 = p3.x - p1.x, b2 = p3.y - p1.y, c2 = (a2 * a2 + b2 * b2) / 2;
	/* translate the origin to p1
	 * let the center of the circumscribed circle be (x, y)
	 * we can get the value of (x, y) by solve the following simultaneous equations to :
	 * a1 * x + b1 * y = c1 --(1)
	 * a2 * x + b2 * y = c2 --(2)
	 *
	 * 1. after rearrange eq.1, we have:
	 * y = (c1 - a1 * x) / b1
	 * plugging this into eq.2, we have:
	 * x = (b1 * c2 - b2 * c1) / (a2 * b1 - a1 * b2)
	 *
	 * 2. after rearrange eq.1, we have:
	 * x = (c1 - b1 * y) / a1
	 * plugging this into eq.2, we have:
	 * y = (a1 * c2 - a2 * c1) / (a1 * b2 - a2 * b1)
	 *   = (a2 * c1 - a1 * c2) / (a2 * b1 - a1 * b2)
	*/
	double d = a2 * b1 - a1 * b2;
	Point center;
	center.x = bias.x + (b1 * c2 - b2 * c1) / d;
	center.y = bias.y + (a2 * c1 - a1 * c2) / d;

	return center;
}

int main() {
	int n;

	while (cin >> n) {
		while (n > 0) {
			Point a, b, c;
			cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;

			Point center = getCircumCircleCenter(a, b, c);
			double radius = countDist(center, a);

			printf("%.3f %.3f %.3f\n", center.x, center.y, radius);

			--n;
		}
	}

	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <string>
#include <cctype>
#include <stack>
#include <queue>
#include <vector>
#include <cstdlib>
#include <list>
#define _USE_MATH_DEFINES
#include <math.h>

using namespace std;

int main() {

	int n;
	double x1, x2, x3, y1, y2, y3;
	double X, Y, R;
	double a, b, c, d, e, f;

	cin >> n;

	for (int i = 0; i < n; i++) {
		scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3);

		a = -x2 + x3;
		b = -x1*x1 + x2*x2 - y1*y1 + y2*y2;
		c = x1 - x2;
		d = -x2*x2 + x3*x3 - y2*y2 + y3*y3;
		e = -c * 2 * (y2 - y3);
		f = a * 2 * (y1 - y2);

		Y = (a*b + c*d) / (e - f);
		X = (b+2*Y*(y1-y2))/(-2*c);
		R = sqrt((X - x1)*(X - x1) + (Y-y1)*(Y-y1));

		if (X > 0)
			X = (int)(X * 1000 + 0.5) ;
		else X = (int)(X * 1000 - 0.5) ;

		if (Y>0)
			Y = (int)(Y * 1000 + 0.5) ;
		else Y = (int)(Y * 1000 - 0.5) ;

		if (R > 0)
			R = (int)(R * 1000 + 0.5);
		else R = (int)(R * 1000 - 0.5);

		printf("%.3f %.3f %.3f\n", X/1000, Y/1000, R/1000);
	}

	return 0;
}

C++: #include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
struct Point{double x,y;};
double dis(Point a,Point b){
  return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
Point tri(Point a, Point b, Point c){
  double a1,a2,b1,b2,c1,c2;
  a1=2*(b.x-a.x);
  b1=2*(b.y-a.y);
  c1=a.x*a.x-b.x*b.x+a.y*a.y-b.y*b.y;
  a2=2*(c.x-a.x);
  b2=2*(c.y-a.y);
  c2=a.x*a.x-c.x*c.x+a.y*a.y-c.y*c.y;
  Point p;
  p.x=(b1*c2-b2*c1)/(a1*b2-a2*b1);
  p.y=(c1*a2-c2*a1)/(a1*b2-a2*b1);
  return p;
}
int main(){
  int n;
  cin >> n;
  int i;
  for(i=0;i<n;i++){
  Point a,b,c;
  cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
  Point x = tri(a,b,c);
  printf("%.3f %.3f %.3f\n",x.x,x.y,dis(x,a));
  }
  return 0;
}

C++: #include<cstdio>
#include<algorithm>
#include<vector>
#include<string>
#include<iostream>
#include<queue>
#include<map>
#include<set>
#include<complex>

using namespace std;

#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)

#define X real()
#define Y imag()

typedef complex<double> P;
class C:public P{
	public:
	double r;
	C(double x,double y,double r):P(x,y),r(r){}
};

template<class T> T sq(T x){return x*x;}
double dot(P a, P b){return a.X*b.X + a.Y*b.Y;}

P solve_eq2(double a,double b,double c,double d,double e,double f){
	double A = a*e-b*d;
	return P((c*e-b*f)/A, (a*f-c*d)/A);
}

C C_PPP(P a,P b,P c){
	P d = b-a;
	P e = c-a;
	
	double z1 = -dot(a,a);
	double z2 = -dot(b,b);
	double z3 = -dot(c,c);
	
	P f = solve_eq2(d.X, d.Y, z2-z1, e.X, e.Y, z3-z1);
	double u = z1-dot(a,f);
	
	return C(-f.X/2, -f.Y/2, sqrt(dot(f,f)/4-u));
}

int main(){
	
	int n;
	cin>>n;
	
	rep(i,n){
		double xa,ya,xb,yb,xc,yc;
		cin>>xa>>ya>>xb>>yb>>xc>>yc;
		
		C circle = C_PPP(P(xa,ya),P(xb,yb),P(xc,yc));
		
		printf("%.3lf %.3lf %.3lf\n",circle.X,circle.Y,circle.r);
	}
}

C++: #include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
    double x1,y1,x2,y2,x3,y3;
    int n;

    scanf("%d",&n);

    double a,b,c;
    double ans = 0;
    double xp,yp;
    for(int i = 0;i < n; i++){
        scanf("%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3);

        a = hypot(x2 - x1,y2 - y1);
        b = hypot(x3 - x1,y3 - y1);
        c = hypot(x3 - x2,y3 - y2);

        ans = (a*b*c) / (sqrt((a+b+c)*(b+c-a)*(a-b+c)*(a+b-c)));
        xp = (((x1*x1)+(y1*y1))*(y2-y3)+((x2*x2)+(y2*y2))*(y3-y1)+((x3*x3)+(y3*y3))*(y1-y2))/(x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2))/2;
        yp = (((x1*x1)+(y1*y1))*(x2-x3)+((x2*x2)+(y2*y2))*(x3-x1)+((x3*x3)+(y3*y3))*(x1-x2))/(y1*(x2-x3)+y2*(x3-x1)+y3*(x1-x2))/2;
        printf("%.3lf %.3lf %.3lf\n",xp,yp,ans);
        ans = 0;
    }
    return 0;
}