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 <cstdio>
#include <cassert>
#include <cmath>
#include <complex>
#include <vector>
#include <utility>
using namespace std;

typedef complex<double> Point;
#define X real()
#define Y imag()
#define EPS 10e-8

namespace std {
  bool operator < (Point a, Point b) {
    if (a.X != b.X) return a.X < b.X;
    return a.Y < b.Y;
  }
}

double cross(Point a, Point b) {
  return (conj(a)*b).Y;
}

double dot(Point a, Point b) {
  return (conj(a)*b).X;
}

double dist2(Point a, Point b) {
  return dot(a-b, a-b);
}

struct Line : public vector<Point> {
  Line(Point a, Point b) {push_back(a); push_back(b);}
};

int n;
Point ps[3];

Line PerpendBisect(Line l) {
  Point mid = (l[0]+l[1])/2.0;
  return Line(mid, mid+(l[1]-l[0])*Point(0, 1));
}

Point GetCrossPoint(Line l, Line 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];
  if (abs(A) < EPS) assert(false);
  return m[0] + B / A * (m[1]-m[0]);
}

double round3(double t) {
  return int(t*1000+0.5)/1000.0;
}

int main() {
  scanf("%d", &n);
  while (n--) {
    for (int i=0; i<3; i++) {
      double x, y;
      scanf("%lf%lf", &x, &y);
      ps[i] = Point(x, y);
    }

    Line l(ps[0], ps[1]);
    Line m(ps[1], ps[2]);
    Point p = GetCrossPoint(PerpendBisect(l), PerpendBisect(m));
    double r = sqrt(dist2(p, ps[0]));
    printf("%.3f %.3f %.3f\n", round3(p.X), round3(p.Y), round3(r));
  }
}

C++: #include <iostream>
#include <cstdio>
#include <vector>
#include <list>
#include <algorithm>
#include <cmath>
#include <stack>
#include <set>
using namespace std;

#define REP(i,n) for(int (i)=0; (i)<(n); (i)++)
#define FOR(i,a,b) for(int (i)=(a); (i)<(b); (i)++)
#define PUSH(n,v) for(int i=0; i<(n); i++) {int j; cin >> j; v.push_back(j);}
#define ALL(v) v.begin(), v.end()

const double ERR = 1e-9;

typedef pair<double, double> XY;

XY solveeq(double a, double b, double c, double d, double e, double f) {
    double x, y;
    x = (c*e - b*f)/(a*e - b*d);
    y = (a*f - c*d)/(a*e - b*d);
    return make_pair(x,y);
}

XY getcenter(double x1, double y1, double x2, double y2, double x3, double y3) {
    return solveeq((x2-x1)/(y2-y1+ERR), 1, (x2*x2-x1*x1)/2/(y2-y1+ERR)+(y1+y2)/2, (x3-x2)/(y3-y2+ERR), 1, (x3*x3-x2*x2)/2/(y3-y2+ERR)+(y2+y3)/2);
}

double getradius(XY center, double x1, double y1) {
    return sqrt((x1-center.first)*(x1-center.first) + (y1-center.second)*(y1-center.second));
}

int main() {
    double x1,y1,x2,y2,x3,y3;
    int n;
    cin >> n;
    REP(i,n) {
        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        XY center = getcenter(x1, y1, x2, y2, x3, y3);
        double radius = getradius(center, x1, y1);
        printf("%.3f %.3f %.3f\n", center.first+ERR, center.second+ERR, radius+ERR);
    }
    return 0;
}

C++: //04
#include<iostream>
#include<complex>
#include<iomanip>
#include<cmath>
#include<algorithm>

#define S(X) ((X)*(X))

using namespace std;

int main(){
  int n;
  cin>>n;
  for(int i=0;i<n;i++){
    complex<double> p[3];
    for(int j=0;j<3;j++){
      double x,y;
      cin>>x>>y;
      p[j]=complex<double>(x,y);
    }
    complex<double> t[2];
    t[0]=p[1]-p[0];
    t[1]=p[2]-p[0];
    if(t[0].real()*t[1].imag()-t[0].imag()*t[1].real()<0){
      swap(p[1],p[2]);
    }
    double d[3];
    for(int j=0;j<3;j++){
      d[j]=abs(p[j]-p[(j+1)%3]);
    }
    double r=d[0]/2/sqrt(1-S((S(d[1])+S(d[2])-S(d[0]))/2/d[1]/d[2]));
    complex<double> c=p[0]+polar(r,arg(p[1]-p[0])+acos(d[0]/2/r));
    cout<<fixed<<setprecision(3)<<c.real()<<' '<<c.imag()<<' '<<r<<endl;
  }
  return 0;
}

C++: #include<iostream>
#include<cmath>
using namespace std;
int main(){
int k;
double x[3], y[3], a, b, c, d, e, f, l , m, n;
cin >> k;
while(k--){
cin>> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2];
a = 2 * (x[1] - x[0]);
b = 2 * (y[1] - y[0]);
c = ( (x[1]*x[1]) + (y[1]*y[1]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
d = 2 * (x[2] - x[0]);
e = 2 * (y[2] - y[0]);
f = ( (x[2]*x[2]) + (y[2]*y[2]) ) -( (x[0]*x[0]) + (y[0]*y[0]) );
l = (c*e - f*b) / (a*e - d*b);
m = (c*d - f*a) / (b*d - e*a);
n = sqrt((l - x[0])*(l - x[0]) + (m - y[0])*(m - y[0]));
cout << fixed << setprecision(3) << l << " " << m << " " << n << endl;
}
}

C++: #include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
#define sqr(x) (x)*(x)
int main(){
  int n;cin>>n;
  double x[3],y[3];
  double px,py,a,b,c,co,si,r;
  for(int i=0;i<3;i++)
    cin>>x[i]>>y[i];
  a=sqrt((sqr(x[1]-x[0])+sqr(y[1]-y[0])));
  b=sqrt((sqr(x[2]-x[1])+sqr(y[2]-y[1])));
  c=sqrt((sqr(x[0]-x[2])+sqr(y[0]-y[2])));
  //cout<<a<<" "<<b<<" "<<c<<endl;
  co=((a*a)-(b*b)-(c*c))/(2*b*c);
  si=sqrt((1-(sqr(co))));
  //cout<<co<<" "<<si<<endl;
  r=a/(si*2.0);
  px=((y[2]-y[1])*(sqr(x[1])+sqr(y[1])-sqr(x[0])-sqr(y[0]))+(y[0]-y[1])*(sqr(x[2])+sqr(y[2])-sqr(x[1])-sqr(y[1])))/(2*((x[1]-x[0])*(y[2]-y[1])-(y[1]-y[0])*(x[2]-x[1])));
  py=((x[1]-x[2])*(sqr(x[1])+sqr(y[1])-sqr(x[0])-sqr(y[0]))+(x[1]-y[0])*(sqr(x[2])+sqr(y[2])-sqr(x[1])-sqr(y[1])))/(2*((x[1]-x[0])*(y[2]-y[1])-(y[1]-y[0])*(x[2]-x[1])));
  if(px==0)
    px=0;
  if(py==0)
    py=0;

  printf("%.3lf %.3lf %.3lf\n",px,py,r);
  return 0;
}

C++: #include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <functional>
#include <array>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
#include <memory.h>
#include <map>
#include <math.h>
#include <utility>


#pragma warning(disable:4996)
using namespace std;
#define REP(i,n) for(int i = 0 ; i < n ; ++i)
typedef long long Int;
const double PI = 3.141592653589793238;
const Int INF = 999999999999;
typedef pair<int, int> P;


int main()
{
	int n;
	cin >> n;
	REP(i, n){
		double x1, x2, x3, y1, y2, y3;
		cin >> x1>> x2 >> x3 >> y1 >> y2 >> y3;

		double x21 = x2 - x1;
		double x31 = x3 - x1;
		double y21 = y2 - y1;
		double y31 = y3 - y1;

		double xc = ((y31*(x21*x21 + y21*y21)) - (y21*(x31*x31 + y31*y31))) /
			(2 * (x21*y31 - y21*x31));

		double yc = ((x21*(x31*x31 + y31*y31)) - (x31*(x21*x21 + y21*y21))) /
			(2 * (x21*y31 - y21*x31));	
		
		double d = (xc - x1)*(xc - x1) + (yc - y1)*(yc - y1);
		d = sqrt(d);
		double a = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));

		double b = sqrt((x1 - x3)*(x1 - x3) + (y1 - y3)*(y1 - y3));

		double c = sqrt((x3 - x2)*(x3 - x2) + (y3 - y2)*(y3 - y2));

		d = a*b*c / (sqrt((a + b + c)*(-a + b + c)*(a - b + c)*(a + b - c)));

		printf("%.3lf %.3lf %.3lf\n", xc, yc, d);
	}

}