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++: /*
C++ ???????????????????????????????????¬??????
??????AOJ-ITP1??????????????????
*/
#define _USE_MATH_DEFINES

#include <iostream> // ?¨??????\??????
#include <fstream>  // ??????????????\??????
#include <string>   // ???????????¢???
#include <vector>   // ???????????????
#include <cmath>    // ??°??????
#include <iomanip>  // stream???????????¢???
#include <algorithm>// max??¢??°??????

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;        // ????´???°????????????????????????
using std::fixed;         // ???????????????????¨???????????????????????????????
using std::setprecision;  // ?????°????°???°?????\???????????°????????????????????¨????????\???
using std::pow;

int main() {
	int num;
	double x1, y1, x2, y2, x3, y3;
	

	cin >> num;
	for (size_t i = 0; i < num; i++)
	{
		double p, q, r;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		p = ((y1 - y3)*(pow(y1, 2.0) - pow(y2, 2.0) + pow(x1, 2.0) - pow(x2, 2.0)) - (y1 - y2)*(pow(y1, 2.0) - pow(y3, 2.0) + pow(x1, 2.0) - pow(x3, 2.0))) / (2*(y1 - y3)*(x1 - x2) - 2*(y1 - y2)*(x1 - x3));
		q = ((x1 - x3)*(pow(x1, 2.0) - pow(x2, 2.0) + pow(y1, 2.0) - pow(y2, 2.0)) - (x1 - x2)*(pow(x1, 2.0) - pow(x3, 2.0) + pow(y1, 2.0) - pow(y3, 2.0))) / (2*(x1 - x3)*(y1 - y2) - 2*(x1 - x2)*(y1 - y3));

		r = sqrt(pow((p - x1), 2.0) + pow((q - x2), 2.0));

		cout << p << " " << q  << " " << r << endl;
	}

	return 0;
}

C++: #include<iostream>
#include<math.h>
using namespace std;

typedef pair<double,double>vec;

vec operator + (vec v1,vec v2){
    return make_pair(v1.first+v2.first,v1.second+v2.second);
}

vec operator - (vec v1,vec v2){
    return make_pair(v1.first-v2.first,v1.second-v2.second);
}

vec operator * (double v,vec v2){
    return make_pair(v*v2.first,v*v2.second);
}

vec operator / (vec v1,double d){
    return make_pair(v1.first/d,v1.second/d);
}

int norm2(vec v1,vec v2){
    return (v1-v2).first*(v1-v2).first+(v1-v2).second*(v1-v2).second;
}

int main(){
    double x1,x2,x3,y1,y2,y3,n,r,x4,y4;
    cin>>n;
    while(n--){
        cin>>x1>>y1>>x2>>y2>>x3>>y3;
        vec A = make_pair(x1,y1);
        vec B = make_pair(x2,y2);
        vec C = make_pair(x3,y3);
        double a2,b2,c2,a,b,c,cosA,cosB,cosC,sinA,sinB,sinC,cos2A,cos2B,cos2C,sin2A,sin2B,sin2C;
        a2=norm2(B,C);
        b2=norm2(A,C);
        c2=norm2(A,B);
        a=sqrt(a2);
        b=sqrt(b2);
        c=sqrt(c2);
        cosA=(b2+c2-a2)/(2*b*c);
        cosB=(a2+c2-b2)/(2*c*a);
        cosC=(b2+a2-c2)/(2*b*a);
        sinA=sqrt(1-cosA*cosA);
        sinB=sqrt(1-cosB*cosB);
        sinC=sqrt(1-cosC*cosC);
        r=(a/sinA)/2;
        cos2A=cosA*cosA-sinA*sinA;
        cos2B=cosB*cosB-sinB*sinB;
        cos2C=cosC*cosC-sinC*sinC;
        sin2A=2*sinA*cosA;
        sin2B=2*sinB*cosB;
        sin2C=2*sinC*cosC;
        
        vec v=(sin2A*A+sin2B*B+sin2C*C )   /    (sin2A+sin2B+sin2C);
        printf("%.3f %.3f %.3f\n",v.first,v.second,r);
    }
    
}

C++: #include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main()
{
	int n;
	double x1, x2, x3;
	double y1, y2, y3;
	cin >> n;
	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
	double px, py, r;
	double A = (x2 - x1)*(y3 - y2) - (y2 - y1)*(x3 - x2);
	px = 0.5*((y3 - y2)*(x2*x2 - x1*x1 + y2*y2 - y1*y1) - (y2 - y1)*(x3*x3 - x2*x2 + y3*y3 - y2*y2)) / A;
	py = 0.5*(-(x3 - x2)*(x2*x2 - x1*x1 + y2*y2 - y1*y1) + (x2 - x1)*(x3*x3 - x2*x2 + y3*y3 - y2*y2)) / A;
	double a = px - x1;
	double b = py - y1;
	double r0 = (a*a + b*b);
	double r1 = sqrt(r0);
	cout << fixed << setprecision(10) << px << " " << py << " " << r1 <<  endl;
}

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

inline sqr(double x){return x*x;}
inline double Roundoff(double x){
	if( x<0 ){
		x*=-1;
		x=(x-(x-int(x*1000)/1000))+(((x*1000)-int(x*1000))*10)>=4?0.001:0;
		x*=-1;
	}else{
		x=(x-(x-int(x*1000)/1000))+(((x*1000)-int(x*1000))*10)>=4?0.001:0;
	}
	return x;
}

void SolveSimultEq(double &x,double &y,double a,double b,double c,double d,double e,double f);
int main(){
	int datanum;
	double *x1,*y1,*x2,*y2,*x3,*y3;
	cin>>datanum;
	x1=new double[datanum];
	y1=new double[datanum];
	x2=new double[datanum];
	y2=new double[datanum];
	x3=new double[datanum];
	y3=new double[datanum];
	
	for( int i=0;i<datanum;i++ ){
		cin>>x1[i]>>y1[i]>>x2[i]>>y2[i]>>x3[i]>>y3[i];
	}
	for( int i=0;i<datanum;i++ ){
		double px,py,r;
		
		SolveSimultEq(px,py,2*(x1[i]-x2[i]),2*(y1[i]-y2[i]),sqr(x1[i])-sqr(x2[i])+sqr(y1[i])-sqr(y2[i]),
  			  	    2*(x2[i]-x3[i]),2*(y2[i]-y3[i]),sqr(x2[i])-sqr(x3[i])+sqr(y2[i])-sqr(y3[i]));
		r=sqrt(sqr(x1[i]-px)+sqr(y1[i]-py));
		cout<<fixed<<setprecision(3)<<px<<" "<<setprecision(3)<<py<<" "<<setprecision(3)<<r<<endl;

	}

	delete x1;
	delete y1;
	delete x2;
	delete y2;
	delete x3;
	delete y3;
	return 0;
}

void SolveSimultEq(double &x,double &y,double a,double b,double c,double d,double e,double f){
	double delta=a*e-b*d;
	
	x=(c*e-b*f)/delta;
	y=(a*f-c*d)/delta;
}

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

double sisya(double x)
{
	int a = static_cast<int>(x * 10000);
	x = static_cast<double>(static_cast<int>(x * 1000)) / 1000;
	if(a < 0 && a%10 <= -5)
		return x-0.001;
	else if(a%10 >= 5)
		return x+0.001;
	return x;
}

double dif(double x,double y,double xx, double yy)
{
	return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
}

int main()
{
	int n;
	double x1,x2,x3,y1,y2,y3;
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		double px = max(x1,max(x2,x3)) - (max(x1,max(x2,x3)) - min(x1,min(x2,x3))) / 2;
		double py = max(y1,max(y2,y3)) - (max(y1,max(y2,y3)) - min(y1,min(y2,y3))) / 2;
		double r  = dif(x1,y1,px,py);
		cout << setprecision(3) << fixed << sisya(px) << " " << setprecision(3) << fixed << sisya(py) << " " << setprecision(3) << fixed << sisya(r) <<endl;
	}
	return 0;
}

C++: #include<iostream>
#include<complex>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstdio>

using namespace std;

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

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

typedef long double D;
typedef complex<D> P;

D aTri(D a, D b, D c){
  D s = (a + b + c) / 2;
  return sqrt(max(s * (s - a) * (s - b) * (s - c), (D)0));
}

P circumscribedCircleCenter(P a, P b, P c) {
  D ax = a.X, ay = a.Y;
  D bx = b.X, by = b.Y;
  D cx = c.X, cy = c.Y;
  D d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
  return P(((ay * ay + ax * ax) * (by - cy) + by * by + bx * bx * (cy - ay) +
	    (cy * cy + cx * cx) * (ay - by)) / d,
	   ((ay * ay + ax * ax) * (cx - bx) + by * by + bx * bx * (ax - cx) +
	    (cy * cy + cx * cx) * (bx - ax)) / d);
}

D circumscribedCircleRadius(D a, D b, D c) {return a * b * c / (4 * aTri(a, b, c));}

int main() {
  int n;
  cin >> n;
  rep (i, n) {
    P a, b, c;
    cin >> a.X >> a.Y >> b.X >> b.Y >> c.X >> c.Y;
    P p = circumscribedCircleCenter(a, b, c);
    D r = circumscribedCircleRadius(abs(a - b), abs(b - c), abs(c - a));
    printf("%.3Lf %.3Lf %.3Lf\n", p.X, p.Y, r);
  }
  return 0;
}