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<iostream>
#include<cmath>
#include<stdio.h>
using namespace std;
int main() {
  int n=0;
  double ax,ay,bx,by,cx,cy,S,R,a,b,c,x,y;
  cin>>n;
  for(int i=0; i<n; i++){
    cin>>ax>>ay>>bx>>by>>cx>>cy;
    S=abs(((bx-ax)*(cy-ay)-(cx-ax)*(by-ay))/2);
    a=sqrt((cx-bx)*(cx-bx)+(cy-by)*(cy-by));
    b=sqrt((cx-ax)*(cx-ax)+(cy-ay)*(cy-ay));
    c=sqrt((ax-bx)*(ax-bx)+(ay-by)*(ay-by));
    R=a*b*c/(4*S);
    x=(a*a*(b*b+c*c-a*a)*ax+b*b*(c*c+a*a-b*b)*bx+c*c*(a*a+b*b-c*c)*cx)/(16*S*S);
    y=(a*a*(b*b+c*c-a*a)*ay+b*b*(c*c+a*a-b*b)*by+c*c*(a*a+b*b-c*c)*cy)/(16*S*S);
    printf("%.3f %.3f %.3f\n",x,y,R);
  }
}

C++: #include<iostream>
#include<iomanip>
#include<cmath>
#define PI 3.1415
using namespace std;

int main(){

	int n;
	double x1, y1, x2, y2, x3, y3;
	double la, lb, lc;
	double a, b, c;
	
	double r;
	double px, py;

	cin >> n;

	for(int i=0;i<n;i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

		//lc = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
		la = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
		//lb = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);

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


		if( a >= PI ) a=2*PI-a;
		if( b >= PI ) b=2*PI-b;
		if( c >= PI ) c=2*PI-c;


		r = sqrt(la) / (sin(a)*2);
		px = ( sin(2*a) * x1 + sin(2*b) * x2 + sin(2*c) * x3 ) / (sin(2*a)+sin(2*b)+sin(2*c));
		py = ( sin(2*a) * y1 + sin(2*b) * y2 + sin(2*c) * y3 ) / (sin(2*a)+sin(2*b)+sin(2*c));

		r = floor(r*1000+0.5)/1000;
		px = floor(px*1000+0.5)/1000;
		py = floor(py*1000+0.5)/1000;

		cout << setprecision(3) << fixed  << px << " " << py << " " << r << endl;

	}
	return 0;
}

C++: #include<stdio.h>
#include<math.h>

int main()
{
	int n;
	double x1,x2,x3,y1,y2,y3,x,y,r;
	double a,b,c;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3);
	    x=(y1-y3)*(y1*y1-y2*y2+x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3);
	    x/=(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));

	    y=(x1-x3)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3);
	    y/=(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));

	    a=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
	    b=(x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
	    c=(x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
	    a=sqrt(a);
	    b=sqrt(b);
	    c=sqrt(c);
	    r=a*b*c/sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));

		printf("%.3f %.3f %.3f\n",x,y,r);
	}
	return 0;
}
/*?????\???*/

C++: #include <iostream>
#include <cmath>
using namespace std;

//0010
int main(){
	int n;
	while(cin >> n){
		double x1,y1,x2,y2,x3,y3,x,y,r;

		while(n--){
			cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

			if(x1!=x2){
				x=(x1+x2)/2;
			}else if(x2!=x3){
				x=(x2+x3)/2;
			}else if(x3!=x1){
				x=(x3+x1)/2;
			}
			if(y1!=y2){
				y=(y1+y2)/2;
			}else if(y2!=y3){
				y=(y2+y3)/2;
			}else if(y3!=y1){
				y=(y3+y1)/2;
			}

			r=sqrt(pow(x-x1,2)+pow(y-y1,2));
			cout.setf(ios::fixed);
			cout.precision(3);
			cout << x << " " << y << " " << r << endl;
		}
	}

}

C++: #import<complex>
#import<cstdio>
#define F(a,b,c) acos((b*b+c*c-a*a)/2/b/c)
int main(){typedef double D;int n;D d,e,f,g,h,i;for(scanf("%d",&n);n--;){scanf("%lf%lf%lf%lf%lf%lf",&d,&g,&e,&h,&f,&i);std::complex<D> a(d,g),b(e,h),c(f,i);D A=abs(b-c),B=abs(c-a),C=abs(a-b),L=F(A,B,C),s=sin(2*L),t=sin(2*F(B,C,A)),u=sin(2*F(C,A,B)),v=s+t+u;printf("%.3f %.3f %.3f\n",(d*s+e*t+f*u)/v,(g*s+h*t+i*u)/v,A/sin(L)/2);}}

C++: #include <iostream>
#include <cmath>

using namespace std;
typedef struct { double x; double y;} point;
 
point getCircumcenter(point a, point b, point c)
{
    double A1 = 2 * ( b.x - a.x );
    double B1 = 2 * ( b.y - a.y );
    double C1 = pow(a.x,2)-pow(b.x,2) + pow(a.y,2)-pow(b.y,2);
    double A2 = 2 * ( c.x - a.x );
    double B2 = 2 * ( c.y - a.y );
    double C2 = pow(a.x,2)-pow(c.x,2) + pow(a.y,2)-pow(c.y,2);
    double X = (B1 * C2 - B2 * C1) / (A1 * B2 - A2 * B1);
    double Y = (C1 * A2 - C2 * A1) / (A1 * B2 - A2 * B1);
	point P;
	P.x=X;
	P.y=Y;
    return P;
}

double getTwoPointDictance(point a, point b)
{
	return fabs(sqrt(pow((a.x-b.x),2)+pow((a.y-b.y),2)));
}
double AntiMinusZero(double n)
{
	if(n==0)
	{
		return 0;
	}
	return n;
}

int main()
{
    int n;
    cin>>n;
    point a,b,c;
    while(n--)
	{
        cin>>a.x>>a.y>>b.x>>b.y>>c.x>>c.y;
        point ans = getCircumcenter(a,b,c);
        printf("%.3lf %.3lf %.3lf", AntiMinusZero(ans.x), AntiMinusZero(ans.y), getTwoPointDictance( a, ans));
    }
}

C++: #include <iostream>
#include <complex>
#include <cassert>
#include <vector>
#include <iomanip>

using namespace std;

typedef complex<double> P;

#define loop(i,a,b) for(int i=(a); i<(int)(b); i++)
#define rep(i,b) loop(i,0,b)

const double eps = 1e-10;

double cross(const P& a, const P& b) {
    return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
    return real(conj(a)*b);
}

struct L : public vector<P> {
    L(const P &a, const P &b) {
        push_back(a); push_back(b);
    }
};

P crosspoint(const L &l, const L &m) {
    double A = cross(l[1] - l[0], m[1] - m[0]);
    double B = cross(l[1] - l[0], l[1] - m[0]);
    if (abs(A) < eps && abs(B) < eps) return m[0]; // same line
    if (abs(A) < eps) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
    return m[0] + B / A * (m[1] - m[0]);
}

int main(){
    cout << setprecision(3) << fixed;
    P ps[3];
    int n; cin>>n;
    rep(tt,n){
        rep(i,3){
            double x,y; cin>>x>>y;
            ps[i] = P(x,y);
        }
        P mid1 = (ps[0]+ps[1])/2.0;
        P mid2 = (ps[0]+ps[2])/2.0;

        L l1(mid1, mid1+(ps[0]-ps[1])*P(0,1));
        L l2(mid2, mid2+(ps[0]-ps[2])*P(0,1));

        P cp = crosspoint(l1,l2);

        cout << cp.real() << " " << cp.imag() << " " << abs(cp-ps[0]) << endl;
    }
}