Go: package main

import (
	"fmt"
	"math"
)

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

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

func circleTriangle() {
	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 <vector>
#include <cmath>
#include <iomanip>

using namespace std;

struct point{
    double x;
    double y;
};

struct linear{
    double a;
    double b;
    double c;
};

linear get_linear(point a, point b){
    linear l;

    if(a.x == b.x){
        l.a = 1;
        l.b = 0;
        l.c = a.x;
    }else if(a.y == b.y){
        l.a = 0;
        l.b = 1;
        l.c = a.y;
    }else{
        l.a = (b.x-a.x)/(b.y-a.y);
        l.b = -1;
        l.c = a.x * l.a - a.y;
    }
    return l;
}

linear get_linear_vertical(point p, linear l){
    linear lv;
    lv.a = (-1)*l.b;
    lv.b = l.a;
    lv.c = lv.a*p.x + lv.b*p.y;
    return lv;
}

point get_cross_point(linear l1, linear l2){
    point p;
    p.x = (l1.b*l2.c - l1.c*l2.b)/(l1.b*l2.a - l1.a*l2.b);
    p.y = (l1.c*l2.a - l1.a*l2.c)/(l1.b*l2.a - l1.a*l2.b);
    return p;
}

double round3dig(double d){
    d *= 1000;
    d += (0.5 - (d < 0));
    d = int(d);
    if(d != 0)
        d /= 1000;
    return d;
}

double point_distance(point s, point e){
    double d;
    d = (e.x - s.x)*(e.x - s.x)+(e.y - s.y)*(e.y - s.y);
    d = sqrt(d);
    return d;
}

int main()
{
    int n;
    double r;
    point p[3], mp, cp;
    linear l1, l2;

    cin >> n;
    vector< point > v[n];
    for(int i = 0; i < n; ++i){
        cin >> p[0].x >> p[0].y >> p[1].x >> p[1].y >> p[2].x >> p[2].y;
        v[i].push_back(p[0]);
        v[i].push_back(p[1]);
        v[i].push_back(p[2]);
    }
    for(int i = 0; i < n; ++i){
        l1 = get_linear(v[i].at(0), v[i].at(1));
        mp.x = (v[i].at(1).x + v[i].at(0).x)/2;
        mp.y = (v[i].at(1).y + v[i].at(0).y)/2;
        l1 = get_linear_vertical(mp, l1);

        l2 = get_linear(v[i].at(0), v[i].at(2));
        mp.x = (v[i].at(2).x + v[i].at(0).x)/2;
        mp.y = (v[i].at(2).y + v[i].at(0).y)/2;
        l2 = get_linear_vertical(mp, l2);

        cp = get_cross_point(l1, l2);
        r = point_distance(v[i].at(0), cp);

        cp.x = round3dig(cp.x);
        cp.y = round3dig(cp.y);
        r = round3dig(r);

        cout << fixed << setprecision(3)
             << cp.x << ' ' << cp.y << ' ' << r << endl;
    }
    return 0;
}

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

int main(){
	int n;
	double x1 , y1 , x2 , y2 , x3 , y3;
	double a1 , b1 , c1 , a2 , b2 , c2;
	double a , b , c;
	double px , py , r;
	double tmp;
	cin >> n;
	while(1){
		if(n==0) break;
		n--;
		cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		a1=2*(x2-x1);
		b1=2*(y2-y1);
		c1=(x1*x1-x2*x2+y1*y1-y2*y2);
		a2=2*(x3-x1);
		b2=2*(y3-y1);
		c2=(x1*x1-x3*x3+y1*y1-y3*y3);
		px=(b1*c2-b2*c1)/(a1*b2-a2*b1);
		py=(c1*a2-c2*a1)/(a1*b2-a2*b1);
		a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		b=sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
		c=sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));
		r=a/(2*sqrt(1-((b*b+c*c-a*a)/(2*b*c))*((b*b+c*c-a*a)/(2*b*c))));
		tmp=px*1000+0.5;
		px=(int)tmp;
		px/=1000;
		tmp=px*1000+0.5;
		py=(int)tmp;
		py/=1000;
		tmp=r*1000+0.5;
		r=(int)tmp;
		r/=1000;
		cout << fixed << setprecision(3) << px << " " << py << " " << r << endl;
	}
	return 0;
}

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

int main(){

  double x1, x2, x3, y1, y2, y3, k12, k23, p, q, r;
  int n;
  
  cin >> n;
  
  for(int i=0; i<n; i++){
  	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
  	
  	if(y1 != y2){
  		k12 = - (x1 - x2) / (y1 - y2);
  	}
  	else {
  		p = (x1 + x2) / 2.0;
  		q = - (x2 - x3) / (y2 - y3) * (p - (x2 + x3) / 2.0) + (y2 + y3) / 2.0;
  		r = sqrt(pow(p - x1, 2) + pow(q - y1, 2));
  		
  		printf("%.3lf %.3lf %.3lf\n", p, q, r);
  		continue;
  	}
  	
  	if(y2 != y3){
  		k23 = - (x2 - x3) / (y2 - y3);
  	}
  	else {
  		p = (x2 + x3) / 2.0;
  		q = - (x1 - x2) / (y1 - y2) * (p - (x1 + x2) / 2.0) + (y1 + y2) / 2.0;
  		r = sqrt(pow(p - x1, 2) + pow(q - y1, 2));
  		
  		printf("%.3lf %.3lf %.3lf\n", p, q, r);
  		continue;
  	}
  	
  	p = (k12 * ((x1 + x2) / 2.0) - (y1 + y2) / 2.0 - k23 * ((x2 + x3) / 2.0) + (y2 + y3) / 2.0) / (k12 - k23);
  	q = - (x1 - x2) / (y1 - y2) * (p - (x1 + x2) / 2.0) + (y1 + y2) / 2.0;
  	r = sqrt(pow(p - x1, 2) + pow(q - y1, 2));
  	
  	printf("%.3lf %.3lf %.3lf\n", p, q, r);
	}  

  return 0;
}

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

// _ÀWð^Æ·é
typedef complex<double> P;
// ÎÌè`
#define PI 3.1415926535898

// e·éë·Ã
#define EPS (1e-10)
//XYÀW
#define X real()
#define Y imag()
	
// Op`NX
class Triangle{

private:
	//Op`ÌR_ÌÀW
	P a, b, c;
	//Op`ÌRÓÌ·³
	double edgeA,edgeB,edgeC;
	//Op`ÌRpÌå«³(WA)
	double angleA,angleB,angleC;
	//]·è©çRÂÌpxðßéÖ
	double LawOfCosines(double a,double b, double c){
		return acos( (b*b+c*c-a*a) / (2.0*b*c) );
	}
	//QÂÌdouble^Ìlªµ¢©Ç¤©
	bool equal(double a, double b){
		return (abs( a-b ) < EPS)? true : false ;
	}

public:
	//RXgN^(RÂÌ_ÆÓÆpxðú»)
	Triangle(P p1, P p2, P p3){
		a = p1;
		b = p2;
		c = p3;
		edgeB = abs(c-a);
		edgeA = abs(b-c);
		edgeC = abs(a-b);
		angleA = LawOfCosines(edgeA,edgeB,edgeC);
		angleB = LawOfCosines(edgeB,edgeC,edgeA);
		angleC = LawOfCosines(edgeC,edgeA,edgeB);
	}
	
	double circumscribedCircleRadius(){//OÚ~Ì¼aðÔ·
		return ( edgeA / sin(angleA) / 2.0 );
	}
	double circumscribedCircleX(){//OS(OÚ~ÌS)ÌXÀWðÔ·
		double A = sin(2.0*angleA);
		double B = sin(2.0*angleB);
		double C = sin(2.0*angleC);
		return ( (a.X * A + b.X * B + c.X * C) / (A+B+C) );
	}
	double circumscribedCircleY(){//OS(OÚ~ÌS)ÌYÀWðÔ·
		double A = sin(2.0*angleA);
		double B = sin(2.0*angleB);
		double C = sin(2.0*angleC);
		return ( (a.Y * A + b.Y * B + c.Y * C) / (A+B+C) );
	}
};

int main(){
	int n;
	double x1, x2, x3, y1, y2, y3;
	double r, xp, yp;

	scanf("%d", &n);
	for (int i=0 ; i<n ; i++){
		scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3);
		P a( x1 , y1 );
		P b( x2 , y2 );
		P c( x3 , y3 );
		Triangle Tr(a,b,c);
		r  = Tr.circumscribedCircleRadius();
		xp = Tr.circumscribedCircleX();
		yp = Tr.circumscribedCircleY();
		printf("%.3f %.3f %.3f\n", xp,yp,r);
	}
}