func Compress32(input []byte) {
/* compress */
start, in, data := time.Now(), make(chan []byte, 1), make([]byte, len(input))
copy(data, input)
buffer := &bytes.Buffer{}
in <- data
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptiveCoder32().Code(buffer)
fmt.Println("adaptive coder 32")
fmt.Printf("compressed=%v\n", buffer.Len())
fmt.Printf("ratio=%v\n", float64(buffer.Len())/float64(len(input)))
fmt.Println(time.Now().Sub(start).String())
/* decompress */
start, in = time.Now(), make(chan []byte, 1)
uncompressed := make([]byte, len(input))
in <- uncompressed
close(in)
compress.BijectiveBurrowsWheelerDecoder(in).MoveToFrontRunLengthDecoder().AdaptiveDecoder32().Decode(buffer)
if bytes.Compare(input, uncompressed) != 0 {
fmt.Println("decompression didn't work")
} else {
fmt.Println("decompression worked")
}
fmt.Println(time.Now().Sub(start).String())
/* compress */
start, in = time.Now(), make(chan []byte, 1)
copy(data, input)
buffer.Reset()
in <- data
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptivePredictiveCoder32().Code(buffer)
fmt.Println("\nadaptive predictive coder 32")
fmt.Printf("compressed=%v\n", buffer.Len())
fmt.Printf("ratio=%v\n", float64(buffer.Len())/float64(len(input)))
fmt.Println(time.Now().Sub(start).String())
/* decompress */
start, in = time.Now(), make(chan []byte, 1)
uncompressed = make([]byte, len(input))
in <- uncompressed
close(in)
compress.BijectiveBurrowsWheelerDecoder(in).MoveToFrontRunLengthDecoder().AdaptivePredictiveDecoder32().Decode(buffer)
if bytes.Compare(input, uncompressed) != 0 {
fmt.Println("decompression didn't work")
} else {
fmt.Println("decompression worked")
}
fmt.Println(time.Now().Sub(start).String())
}
func kc(a []byte) float64 {
input, in, output := make([]byte, len(a)), make(chan []byte, 1), &bytes.Buffer{}
copy(input, a)
in <- input
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptiveCoder().Code(output)
return float64(output.Len())
}
func KCSmeans(rawData [][]float64, k int, distanceFunction DistanceFunction, threshold int) ([]int, error) {
var clusteredData []ClusteredObservation
var err error
for clusters := 1; clusters <= k; clusters++ {
data := make([]ClusteredObservation, len(rawData))
for ii, jj := range rawData {
data[ii].Observation = jj
}
seeds := seed(data, clusters, distanceFunction)
clusteredData, err = kmeans(data, seeds, distanceFunction, threshold)
counts := make([]int, clusters)
for _, jj := range clusteredData {
counts[jj.ClusterNumber]++
}
input, width := &bytes.Buffer{}, len(seeds[0])
x := make([]float64, width)
for c := 0; c < clusters; c++ {
err := binary.Write(input, binary.LittleEndian, rand.Float64())
if err != nil {
panic(err)
}
err = binary.Write(input, binary.LittleEndian, int64(counts[c]))
if err != nil {
panic(err)
}
for _, jj := range seeds[c] {
err = binary.Write(input, binary.LittleEndian, jj)
if err != nil {
panic(err)
}
}
for _, j := range clusteredData {
if j.ClusterNumber == c {
/*distance, _ := distanceFunction(j.Observation, seeds[c])
err = binary.Write(input, binary.LittleEndian, distance)
if err != nil {
panic(err)
}*/
for ii, jj := range j.Observation {
x[ii] = jj - seeds[c][ii]
}
if width == 1 {
err = binary.Write(input, binary.LittleEndian, x[0])
if err != nil {
panic(err)
}
} else {
r := 0.0
for _, i := range x {
r += i * i
}
err = binary.Write(input, binary.LittleEndian, math.Sqrt(r))
if err != nil {
panic(err)
}
t := math.Acos(x[1] / math.Sqrt(x[0]*x[0]+x[1]*x[1]))
if t < 0 {
t = 2*math.Pi - t
}
err = binary.Write(input, binary.LittleEndian, t)
if err != nil {
panic(err)
}
for i := 2; i < width; i++ {
r = 0.0
for _, j := range x[:i+1] {
r += j * j
}
err = binary.Write(input, binary.LittleEndian, math.Acos(x[i]/math.Sqrt(r)))
if err != nil {
panic(err)
}
}
}
}
}
}
in, output := make(chan []byte, 1), &bytes.Buffer{}
in <- input.Bytes()
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptiveCoder().Code(output)
fmt.Printf("%v %v\n", clusters, output.Len())
}
labels := make([]int, len(clusteredData))
for ii, jj := range clusteredData {
labels[ii] = jj.ClusterNumber
}
return labels, err
}
func KCMmeans(rawData [][]float64, k int, distanceFunction DistanceFunction, threshold int) ([]int, []Observation, error) {
var minClusteredData []ClusteredObservation
var means []Observation
var err error
max, trace := int64(0), make([]float64, k)
for clusters := 1; clusters <= k; clusters++ {
data := make([]ClusteredObservation, len(rawData))
for ii, jj := range rawData {
data[ii].Observation = jj
}
seeds := seed(data, clusters, distanceFunction)
clusteredData, _ := kmeans(data, seeds, distanceFunction, threshold)
counts := make([]int, clusters)
for _, jj := range clusteredData {
counts[jj.ClusterNumber]++
}
input := &bytes.Buffer{}
for c := 0; c < clusters; c++ {
/*err := binary.Write(input, binary.LittleEndian, rand.Float64())
if err != nil {
panic(err)
}*/
err := binary.Write(input, binary.LittleEndian, int64(counts[c]))
if err != nil {
panic(err)
}
for _, jj := range seeds[c] {
err = binary.Write(input, binary.LittleEndian, jj)
if err != nil {
panic(err)
}
}
for _, j := range clusteredData {
if j.ClusterNumber == c {
for ii, jj := range j.Observation {
err = binary.Write(input, binary.LittleEndian, jj-seeds[c][ii])
if err != nil {
panic(err)
}
}
}
}
}
in, output := make(chan []byte, 1), &bytes.Buffer{}
in <- input.Bytes()
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptiveCoder().Code(output)
/*output := &bytes.Buffer{}
writer := lzma.NewWriterLevel(output, lzma.BestCompression)
writer.Write(input.Bytes())
writer.Close()*/
complexity := int64(output.Len())
trace[clusters-1] = float64(complexity)
fmt.Printf("%v %v\n", clusters, complexity)
if complexity > max {
max, minClusteredData, means = complexity, clusteredData, make([]Observation, len(seeds))
for ii := range seeds {
means[ii] = make([]float64, len(seeds[ii]))
for jj := range seeds[ii] {
means[ii][jj] = seeds[ii][jj]
}
}
}
}
f := fft.FFTReal(trace)
points, phase, complex := make(plotter.XYs, len(f)-1), make(plotter.XYs, len(f)-1), make(plotter.XYs, len(f))
for i, j := range f[1:] {
points[i].X, points[i].Y = float64(i), cmplx.Abs(j)
phase[i].X, phase[i].Y = float64(i), cmplx.Phase(j)
complex[i].X, complex[i].Y = real(j), imag(j)
}
p, err := plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "FFT Real"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
scatter, err := plotter.NewScatter(points)
if err != nil {
panic(err)
}
scatter.Shape = draw.CircleGlyph{}
scatter.Radius = vg.Points(1)
p.Add(scatter)
if err := p.Save(8, 8, "fft_real.png"); err != nil {
panic(err)
}
p, err = plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "FFT Phase"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
scatter, err = plotter.NewScatter(phase)
if err != nil {
panic(err)
}
scatter.Shape = draw.CircleGlyph{}
scatter.Radius = vg.Points(1)
scatter.Color = color.RGBA{0, 0, 255, 255}
p.Add(scatter)
if err := p.Save(8, 8, "fft_phase.png"); err != nil {
panic(err)
}
p, err = plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "FFT Complex"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
scatter, err = plotter.NewScatter(complex)
if err != nil {
panic(err)
}
scatter.Shape = draw.CircleGlyph{}
scatter.Radius = vg.Points(1)
scatter.Color = color.RGBA{0, 0, 255, 255}
p.Add(scatter)
if err := p.Save(8, 8, "fft_complex.png"); err != nil {
panic(err)
}
labels := make([]int, len(minClusteredData))
for ii, jj := range minClusteredData {
labels[ii] = jj.ClusterNumber
}
return labels, means, err
}
func KCmeans(rawData [][]float64, k int, distanceFunction DistanceFunction, threshold, gain int) ([]int, []Observation, error) {
var minClusteredData []ClusteredObservation
var means []Observation
var err error
min := int64(math.MaxInt64)
for clusters := 1; clusters <= k; clusters++ {
data := make([]ClusteredObservation, len(rawData))
for ii, jj := range rawData {
data[ii].Observation = jj
}
seeds := seed(data, clusters, distanceFunction)
clusteredData, _ := kmeans(data, seeds, distanceFunction, threshold)
counts := make([]int, clusters)
for _, jj := range clusteredData {
counts[jj.ClusterNumber]++
}
input := &bytes.Buffer{}
for c := 0; c < clusters; c++ {
err := binary.Write(input, binary.LittleEndian, rand.Float64())
if err != nil {
panic(err)
}
err = binary.Write(input, binary.LittleEndian, int64(counts[c]))
if err != nil {
panic(err)
}
for _, jj := range seeds[c] {
err = binary.Write(input, binary.LittleEndian, jj)
if err != nil {
panic(err)
}
}
/*sigma := make([]float64, len(seeds[c]))*/
for _, j := range clusteredData {
if j.ClusterNumber == c {
for ii, jj := range j.Observation {
x := jj - seeds[c][ii]
//sigma[ii] += x * x
err = binary.Write(input, binary.LittleEndian, x)
if err != nil {
panic(err)
}
}
for ii, jj := range j.Observation {
x := math.Exp(jj - seeds[c][ii])
for i := 0; i < gain; i++ {
err = binary.Write(input, binary.LittleEndian, x*rand.Float64())
if err != nil {
panic(err)
}
}
}
}
}
/*N := float64(counts[c])
for i, j := range sigma {
sigma[i] = math.Sqrt(j / N)
}
for i := 0; i < gain * counts[c]; i++ {
for _, jj := range sigma {
err = binary.Write(input, binary.LittleEndian, 3 * jj * rand.NormFloat64())
if err != nil {
panic(err)
}
}
}*/
}
in, output := make(chan []byte, 1), &bytes.Buffer{}
in <- input.Bytes()
close(in)
compress.BijectiveBurrowsWheelerCoder(in).MoveToFrontRunLengthCoder().AdaptiveCoder().Code(output)
/*output := &bytes.Buffer{}
writer := lzma.NewWriterLevel(output, lzma.BestCompression)
writer.Write(input.Bytes())
writer.Close()*/
complexity := int64(output.Len())
fmt.Printf("%v %v\n", clusters, complexity)
if complexity < min {
min, minClusteredData, means = complexity, clusteredData, make([]Observation, len(seeds))
for ii := range seeds {
means[ii] = make([]float64, len(seeds[ii]))
for jj := range seeds[ii] {
means[ii][jj] = seeds[ii][jj]
}
}
}
}
labels := make([]int, len(minClusteredData))
for ii, jj := range minClusteredData {
labels[ii] = jj.ClusterNumber
}
return labels, means, err
}
