mirror of
https://github.com/golang/go
synced 2024-11-24 22:27:57 -07:00
4f61fc96b2
The ken directory is untouched so we have some examples with explicit semis. R=gri CC=golang-dev https://golang.org/cl/2157041
723 lines
13 KiB
Go
723 lines
13 KiB
Go
// $G $D/$F.go && $L $F.$A && ./$A.out
|
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Power series package
|
|
// A power series is a channel, along which flow rational
|
|
// coefficients. A denominator of zero signifies the end.
|
|
// Original code in Newsqueak by Doug McIlroy.
|
|
// See Squinting at Power Series by Doug McIlroy,
|
|
// http://www.cs.bell-labs.com/who/rsc/thread/squint.pdf
|
|
// Like powser1.go but uses channels of interfaces.
|
|
// Has not been cleaned up as much as powser1.go, to keep
|
|
// it distinct and therefore a different test.
|
|
|
|
package main
|
|
|
|
import "os"
|
|
|
|
type rat struct {
|
|
num, den int64 // numerator, denominator
|
|
}
|
|
|
|
type item interface {
|
|
pr()
|
|
eq(c item) bool
|
|
}
|
|
|
|
func (u *rat) pr(){
|
|
if u.den==1 {
|
|
print(u.num)
|
|
} else {
|
|
print(u.num, "/", u.den)
|
|
}
|
|
print(" ")
|
|
}
|
|
|
|
func (u *rat) eq(c item) bool {
|
|
c1 := c.(*rat)
|
|
return u.num == c1.num && u.den == c1.den
|
|
}
|
|
|
|
type dch struct {
|
|
req chan int
|
|
dat chan item
|
|
nam int
|
|
}
|
|
|
|
type dch2 [2] *dch
|
|
|
|
var chnames string
|
|
var chnameserial int
|
|
var seqno int
|
|
|
|
func mkdch() *dch {
|
|
c := chnameserial % len(chnames)
|
|
chnameserial++
|
|
d := new(dch)
|
|
d.req = make(chan int)
|
|
d.dat = make(chan item)
|
|
d.nam = c
|
|
return d
|
|
}
|
|
|
|
func mkdch2() *dch2 {
|
|
d2 := new(dch2)
|
|
d2[0] = mkdch()
|
|
d2[1] = mkdch()
|
|
return d2
|
|
}
|
|
|
|
// split reads a single demand channel and replicates its
|
|
// output onto two, which may be read at different rates.
|
|
// A process is created at first demand for an item and dies
|
|
// after the item has been sent to both outputs.
|
|
|
|
// When multiple generations of split exist, the newest
|
|
// will service requests on one channel, which is
|
|
// always renamed to be out[0]; the oldest will service
|
|
// requests on the other channel, out[1]. All generations but the
|
|
// newest hold queued data that has already been sent to
|
|
// out[0]. When data has finally been sent to out[1],
|
|
// a signal on the release-wait channel tells the next newer
|
|
// generation to begin servicing out[1].
|
|
|
|
func dosplit(in *dch, out *dch2, wait chan int ){
|
|
both := false // do not service both channels
|
|
|
|
select {
|
|
case <-out[0].req:
|
|
|
|
case <-wait:
|
|
both = true
|
|
select {
|
|
case <-out[0].req:
|
|
|
|
case <-out[1].req:
|
|
out[0],out[1] = out[1], out[0]
|
|
}
|
|
}
|
|
|
|
seqno++
|
|
in.req <- seqno
|
|
release := make(chan int)
|
|
go dosplit(in, out, release)
|
|
dat := <-in.dat
|
|
out[0].dat <- dat
|
|
if !both {
|
|
<-wait
|
|
}
|
|
<-out[1].req
|
|
out[1].dat <- dat
|
|
release <- 0
|
|
}
|
|
|
|
func split(in *dch, out *dch2){
|
|
release := make(chan int)
|
|
go dosplit(in, out, release)
|
|
release <- 0
|
|
}
|
|
|
|
func put(dat item, out *dch){
|
|
<-out.req
|
|
out.dat <- dat
|
|
}
|
|
|
|
func get(in *dch) *rat {
|
|
seqno++
|
|
in.req <- seqno
|
|
return (<-in.dat).(*rat)
|
|
}
|
|
|
|
// Get one item from each of n demand channels
|
|
|
|
func getn(in []*dch) []item {
|
|
n:=len(in)
|
|
if n != 2 { panic("bad n in getn") }
|
|
req := make([] chan int, 2)
|
|
dat := make([] chan item, 2)
|
|
out := make([]item, 2)
|
|
var i int
|
|
var it item
|
|
for i=0; i<n; i++ {
|
|
req[i] = in[i].req
|
|
dat[i] = nil
|
|
}
|
|
for n=2*n; n>0; n-- {
|
|
seqno++
|
|
|
|
select{
|
|
case req[0] <- seqno:
|
|
dat[0] = in[0].dat
|
|
req[0] = nil
|
|
case req[1] <- seqno:
|
|
dat[1] = in[1].dat
|
|
req[1] = nil
|
|
case it = <-dat[0]:
|
|
out[0] = it
|
|
dat[0] = nil
|
|
case it = <-dat[1]:
|
|
out[1] = it
|
|
dat[1] = nil
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Get one item from each of 2 demand channels
|
|
|
|
func get2(in0 *dch, in1 *dch) []item {
|
|
return getn([]*dch{in0, in1})
|
|
}
|
|
|
|
func copy(in *dch, out *dch){
|
|
for {
|
|
<-out.req
|
|
out.dat <- get(in)
|
|
}
|
|
}
|
|
|
|
func repeat(dat item, out *dch){
|
|
for {
|
|
put(dat, out)
|
|
}
|
|
}
|
|
|
|
type PS *dch // power series
|
|
type PS2 *[2] PS // pair of power series
|
|
|
|
var Ones PS
|
|
var Twos PS
|
|
|
|
func mkPS() *dch {
|
|
return mkdch()
|
|
}
|
|
|
|
func mkPS2() *dch2 {
|
|
return mkdch2()
|
|
}
|
|
|
|
// Conventions
|
|
// Upper-case for power series.
|
|
// Lower-case for rationals.
|
|
// Input variables: U,V,...
|
|
// Output variables: ...,Y,Z
|
|
|
|
// Integer gcd; needed for rational arithmetic
|
|
|
|
func gcd (u, v int64) int64{
|
|
if u < 0 { return gcd(-u, v) }
|
|
if u == 0 { return v }
|
|
return gcd(v%u, u)
|
|
}
|
|
|
|
// Make a rational from two ints and from one int
|
|
|
|
func i2tor(u, v int64) *rat{
|
|
g := gcd(u,v)
|
|
r := new(rat)
|
|
if v > 0 {
|
|
r.num = u/g
|
|
r.den = v/g
|
|
} else {
|
|
r.num = -u/g
|
|
r.den = -v/g
|
|
}
|
|
return r
|
|
}
|
|
|
|
func itor(u int64) *rat{
|
|
return i2tor(u, 1)
|
|
}
|
|
|
|
var zero *rat
|
|
var one *rat
|
|
|
|
|
|
// End mark and end test
|
|
|
|
var finis *rat
|
|
|
|
func end(u *rat) int64 {
|
|
if u.den==0 { return 1 }
|
|
return 0
|
|
}
|
|
|
|
// Operations on rationals
|
|
|
|
func add(u, v *rat) *rat {
|
|
g := gcd(u.den,v.den)
|
|
return i2tor(u.num*(v.den/g)+v.num*(u.den/g),u.den*(v.den/g))
|
|
}
|
|
|
|
func mul(u, v *rat) *rat{
|
|
g1 := gcd(u.num,v.den)
|
|
g2 := gcd(u.den,v.num)
|
|
r := new(rat)
|
|
r.num =(u.num/g1)*(v.num/g2)
|
|
r.den = (u.den/g2)*(v.den/g1)
|
|
return r
|
|
}
|
|
|
|
func neg(u *rat) *rat{
|
|
return i2tor(-u.num, u.den)
|
|
}
|
|
|
|
func sub(u, v *rat) *rat{
|
|
return add(u, neg(v))
|
|
}
|
|
|
|
func inv(u *rat) *rat{ // invert a rat
|
|
if u.num == 0 { panic("zero divide in inv") }
|
|
return i2tor(u.den, u.num)
|
|
}
|
|
|
|
// print eval in floating point of PS at x=c to n terms
|
|
func Evaln(c *rat, U PS, n int) {
|
|
xn := float64(1)
|
|
x := float64(c.num)/float64(c.den)
|
|
val := float64(0)
|
|
for i:=0; i<n; i++ {
|
|
u := get(U)
|
|
if end(u) != 0 {
|
|
break
|
|
}
|
|
val = val + x * float64(u.num)/float64(u.den)
|
|
xn = xn*x
|
|
}
|
|
print(val, "\n")
|
|
}
|
|
|
|
// Print n terms of a power series
|
|
func Printn(U PS, n int){
|
|
done := false
|
|
for ; !done && n>0; n-- {
|
|
u := get(U)
|
|
if end(u) != 0 {
|
|
done = true
|
|
} else {
|
|
u.pr()
|
|
}
|
|
}
|
|
print(("\n"))
|
|
}
|
|
|
|
func Print(U PS){
|
|
Printn(U,1000000000)
|
|
}
|
|
|
|
// Evaluate n terms of power series U at x=c
|
|
func eval(c *rat, U PS, n int) *rat{
|
|
if n==0 { return zero }
|
|
y := get(U)
|
|
if end(y) != 0 { return zero }
|
|
return add(y,mul(c,eval(c,U,n-1)))
|
|
}
|
|
|
|
// Power-series constructors return channels on which power
|
|
// series flow. They start an encapsulated generator that
|
|
// puts the terms of the series on the channel.
|
|
|
|
// Make a pair of power series identical to a given power series
|
|
|
|
func Split(U PS) *dch2{
|
|
UU := mkdch2()
|
|
go split(U,UU)
|
|
return UU
|
|
}
|
|
|
|
// Add two power series
|
|
func Add(U, V PS) PS{
|
|
Z := mkPS()
|
|
go func(U, V, Z PS){
|
|
var uv [] item
|
|
for {
|
|
<-Z.req
|
|
uv = get2(U,V)
|
|
switch end(uv[0].(*rat))+2*end(uv[1].(*rat)) {
|
|
case 0:
|
|
Z.dat <- add(uv[0].(*rat), uv[1].(*rat))
|
|
case 1:
|
|
Z.dat <- uv[1]
|
|
copy(V,Z)
|
|
case 2:
|
|
Z.dat <- uv[0]
|
|
copy(U,Z)
|
|
case 3:
|
|
Z.dat <- finis
|
|
}
|
|
}
|
|
}(U, V, Z)
|
|
return Z
|
|
}
|
|
|
|
// Multiply a power series by a constant
|
|
func Cmul(c *rat,U PS) PS{
|
|
Z := mkPS()
|
|
go func(c *rat, U, Z PS){
|
|
done := false
|
|
for !done {
|
|
<-Z.req
|
|
u := get(U)
|
|
if end(u) != 0 {
|
|
done = true
|
|
} else {
|
|
Z.dat <- mul(c,u)
|
|
}
|
|
}
|
|
Z.dat <- finis
|
|
}(c, U, Z)
|
|
return Z
|
|
}
|
|
|
|
// Subtract
|
|
|
|
func Sub(U, V PS) PS{
|
|
return Add(U, Cmul(neg(one), V))
|
|
}
|
|
|
|
// Multiply a power series by the monomial x^n
|
|
|
|
func Monmul(U PS, n int) PS{
|
|
Z := mkPS()
|
|
go func(n int, U PS, Z PS){
|
|
for ; n>0; n-- { put(zero,Z) }
|
|
copy(U,Z)
|
|
}(n, U, Z)
|
|
return Z
|
|
}
|
|
|
|
// Multiply by x
|
|
|
|
func Xmul(U PS) PS{
|
|
return Monmul(U,1)
|
|
}
|
|
|
|
func Rep(c *rat) PS{
|
|
Z := mkPS()
|
|
go repeat(c,Z)
|
|
return Z
|
|
}
|
|
|
|
// Monomial c*x^n
|
|
|
|
func Mon(c *rat, n int) PS{
|
|
Z:=mkPS()
|
|
go func(c *rat, n int, Z PS){
|
|
if(c.num!=0) {
|
|
for ; n>0; n=n-1 { put(zero,Z) }
|
|
put(c,Z)
|
|
}
|
|
put(finis,Z)
|
|
}(c, n, Z)
|
|
return Z
|
|
}
|
|
|
|
func Shift(c *rat, U PS) PS{
|
|
Z := mkPS()
|
|
go func(c *rat, U, Z PS){
|
|
put(c,Z)
|
|
copy(U,Z)
|
|
}(c, U, Z)
|
|
return Z
|
|
}
|
|
|
|
// simple pole at 1: 1/(1-x) = 1 1 1 1 1 ...
|
|
|
|
// Convert array of coefficients, constant term first
|
|
// to a (finite) power series
|
|
|
|
/*
|
|
func Poly(a [] *rat) PS{
|
|
Z:=mkPS()
|
|
begin func(a [] *rat, Z PS){
|
|
j:=0
|
|
done:=0
|
|
for j=len(a); !done&&j>0; j=j-1)
|
|
if(a[j-1].num!=0) done=1
|
|
i:=0
|
|
for(; i<j; i=i+1) put(a[i],Z)
|
|
put(finis,Z)
|
|
}()
|
|
return Z
|
|
}
|
|
*/
|
|
|
|
// Multiply. The algorithm is
|
|
// let U = u + x*UU
|
|
// let V = v + x*VV
|
|
// then UV = u*v + x*(u*VV+v*UU) + x*x*UU*VV
|
|
|
|
func Mul(U, V PS) PS{
|
|
Z:=mkPS()
|
|
go func(U, V, Z PS){
|
|
<-Z.req
|
|
uv := get2(U,V)
|
|
if end(uv[0].(*rat))!=0 || end(uv[1].(*rat)) != 0 {
|
|
Z.dat <- finis
|
|
} else {
|
|
Z.dat <- mul(uv[0].(*rat),uv[1].(*rat))
|
|
UU := Split(U)
|
|
VV := Split(V)
|
|
W := Add(Cmul(uv[0].(*rat),VV[0]),Cmul(uv[1].(*rat),UU[0]))
|
|
<-Z.req
|
|
Z.dat <- get(W)
|
|
copy(Add(W,Mul(UU[1],VV[1])),Z)
|
|
}
|
|
}(U, V, Z)
|
|
return Z
|
|
}
|
|
|
|
// Differentiate
|
|
|
|
func Diff(U PS) PS{
|
|
Z:=mkPS()
|
|
go func(U, Z PS){
|
|
<-Z.req
|
|
u := get(U)
|
|
if end(u) == 0 {
|
|
done:=false
|
|
for i:=1; !done; i++ {
|
|
u = get(U)
|
|
if end(u) != 0 {
|
|
done=true
|
|
} else {
|
|
Z.dat <- mul(itor(int64(i)),u)
|
|
<-Z.req
|
|
}
|
|
}
|
|
}
|
|
Z.dat <- finis
|
|
}(U, Z)
|
|
return Z
|
|
}
|
|
|
|
// Integrate, with const of integration
|
|
func Integ(c *rat,U PS) PS{
|
|
Z:=mkPS()
|
|
go func(c *rat, U, Z PS){
|
|
put(c,Z)
|
|
done:=false
|
|
for i:=1; !done; i++ {
|
|
<-Z.req
|
|
u := get(U)
|
|
if end(u) != 0 { done= true }
|
|
Z.dat <- mul(i2tor(1,int64(i)),u)
|
|
}
|
|
Z.dat <- finis
|
|
}(c, U, Z)
|
|
return Z
|
|
}
|
|
|
|
// Binomial theorem (1+x)^c
|
|
|
|
func Binom(c *rat) PS{
|
|
Z:=mkPS()
|
|
go func(c *rat, Z PS){
|
|
n := 1
|
|
t := itor(1)
|
|
for c.num!=0 {
|
|
put(t,Z)
|
|
t = mul(mul(t,c),i2tor(1,int64(n)))
|
|
c = sub(c,one)
|
|
n++
|
|
}
|
|
put(finis,Z)
|
|
}(c, Z)
|
|
return Z
|
|
}
|
|
|
|
// Reciprocal of a power series
|
|
// let U = u + x*UU
|
|
// let Z = z + x*ZZ
|
|
// (u+x*UU)*(z+x*ZZ) = 1
|
|
// z = 1/u
|
|
// u*ZZ + z*UU +x*UU*ZZ = 0
|
|
// ZZ = -UU*(z+x*ZZ)/u
|
|
|
|
func Recip(U PS) PS{
|
|
Z:=mkPS()
|
|
go func(U, Z PS){
|
|
ZZ:=mkPS2()
|
|
<-Z.req
|
|
z := inv(get(U))
|
|
Z.dat <- z
|
|
split(Mul(Cmul(neg(z),U),Shift(z,ZZ[0])),ZZ)
|
|
copy(ZZ[1],Z)
|
|
}(U, Z)
|
|
return Z
|
|
}
|
|
|
|
// Exponential of a power series with constant term 0
|
|
// (nonzero constant term would make nonrational coefficients)
|
|
// bug: the constant term is simply ignored
|
|
// Z = exp(U)
|
|
// DZ = Z*DU
|
|
// integrate to get Z
|
|
|
|
func Exp(U PS) PS{
|
|
ZZ := mkPS2()
|
|
split(Integ(one,Mul(ZZ[0],Diff(U))),ZZ)
|
|
return ZZ[1]
|
|
}
|
|
|
|
// Substitute V for x in U, where the leading term of V is zero
|
|
// let U = u + x*UU
|
|
// let V = v + x*VV
|
|
// then S(U,V) = u + VV*S(V,UU)
|
|
// bug: a nonzero constant term is ignored
|
|
|
|
func Subst(U, V PS) PS {
|
|
Z:= mkPS()
|
|
go func(U, V, Z PS) {
|
|
VV := Split(V)
|
|
<-Z.req
|
|
u := get(U)
|
|
Z.dat <- u
|
|
if end(u) == 0 {
|
|
if end(get(VV[0])) != 0 {
|
|
put(finis,Z)
|
|
} else {
|
|
copy(Mul(VV[0],Subst(U,VV[1])),Z)
|
|
}
|
|
}
|
|
}(U, V, Z)
|
|
return Z
|
|
}
|
|
|
|
// Monomial Substition: U(c x^n)
|
|
// Each Ui is multiplied by c^i and followed by n-1 zeros
|
|
|
|
func MonSubst(U PS, c0 *rat, n int) PS {
|
|
Z:= mkPS()
|
|
go func(U, Z PS, c0 *rat, n int) {
|
|
c := one
|
|
for {
|
|
<-Z.req
|
|
u := get(U)
|
|
Z.dat <- mul(u, c)
|
|
c = mul(c, c0)
|
|
if end(u) != 0 {
|
|
Z.dat <- finis
|
|
break
|
|
}
|
|
for i := 1; i < n; i++ {
|
|
<-Z.req
|
|
Z.dat <- zero
|
|
}
|
|
}
|
|
}(U, Z, c0, n)
|
|
return Z
|
|
}
|
|
|
|
|
|
func Init() {
|
|
chnameserial = -1
|
|
seqno = 0
|
|
chnames = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
zero = itor(0)
|
|
one = itor(1)
|
|
finis = i2tor(1,0)
|
|
Ones = Rep(one)
|
|
Twos = Rep(itor(2))
|
|
}
|
|
|
|
func check(U PS, c *rat, count int, str string) {
|
|
for i := 0; i < count; i++ {
|
|
r := get(U)
|
|
if !r.eq(c) {
|
|
print("got: ")
|
|
r.pr()
|
|
print("should get ")
|
|
c.pr()
|
|
print("\n")
|
|
panic(str)
|
|
}
|
|
}
|
|
}
|
|
|
|
const N=10
|
|
func checka(U PS, a []*rat, str string) {
|
|
for i := 0; i < N; i++ {
|
|
check(U, a[i], 1, str)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
Init()
|
|
if len(os.Args) > 1 { // print
|
|
print("Ones: "); Printn(Ones, 10)
|
|
print("Twos: "); Printn(Twos, 10)
|
|
print("Add: "); Printn(Add(Ones, Twos), 10)
|
|
print("Diff: "); Printn(Diff(Ones), 10)
|
|
print("Integ: "); Printn(Integ(zero, Ones), 10)
|
|
print("CMul: "); Printn(Cmul(neg(one), Ones), 10)
|
|
print("Sub: "); Printn(Sub(Ones, Twos), 10)
|
|
print("Mul: "); Printn(Mul(Ones, Ones), 10)
|
|
print("Exp: "); Printn(Exp(Ones), 15)
|
|
print("MonSubst: "); Printn(MonSubst(Ones, neg(one), 2), 10)
|
|
print("ATan: "); Printn(Integ(zero, MonSubst(Ones, neg(one), 2)), 10)
|
|
} else { // test
|
|
check(Ones, one, 5, "Ones")
|
|
check(Add(Ones, Ones), itor(2), 0, "Add Ones Ones") // 1 1 1 1 1
|
|
check(Add(Ones, Twos), itor(3), 0, "Add Ones Twos") // 3 3 3 3 3
|
|
a := make([]*rat, N)
|
|
d := Diff(Ones)
|
|
for i:=0; i < N; i++ {
|
|
a[i] = itor(int64(i+1))
|
|
}
|
|
checka(d, a, "Diff") // 1 2 3 4 5
|
|
in := Integ(zero, Ones)
|
|
a[0] = zero // integration constant
|
|
for i:=1; i < N; i++ {
|
|
a[i] = i2tor(1, int64(i))
|
|
}
|
|
checka(in, a, "Integ") // 0 1 1/2 1/3 1/4 1/5
|
|
check(Cmul(neg(one), Twos), itor(-2), 10, "CMul") // -1 -1 -1 -1 -1
|
|
check(Sub(Ones, Twos), itor(-1), 0, "Sub Ones Twos") // -1 -1 -1 -1 -1
|
|
m := Mul(Ones, Ones)
|
|
for i:=0; i < N; i++ {
|
|
a[i] = itor(int64(i+1))
|
|
}
|
|
checka(m, a, "Mul") // 1 2 3 4 5
|
|
e := Exp(Ones)
|
|
a[0] = itor(1)
|
|
a[1] = itor(1)
|
|
a[2] = i2tor(3,2)
|
|
a[3] = i2tor(13,6)
|
|
a[4] = i2tor(73,24)
|
|
a[5] = i2tor(167,40)
|
|
a[6] = i2tor(4051,720)
|
|
a[7] = i2tor(37633,5040)
|
|
a[8] = i2tor(43817,4480)
|
|
a[9] = i2tor(4596553,362880)
|
|
checka(e, a, "Exp") // 1 1 3/2 13/6 73/24
|
|
at := Integ(zero, MonSubst(Ones, neg(one), 2))
|
|
for c, i := 1, 0; i < N; i++ {
|
|
if i%2 == 0 {
|
|
a[i] = zero
|
|
} else {
|
|
a[i] = i2tor(int64(c), int64(i))
|
|
c *= -1
|
|
}
|
|
}
|
|
checka(at, a, "ATan"); // 0 -1 0 -1/3 0 -1/5
|
|
/*
|
|
t := Revert(Integ(zero, MonSubst(Ones, neg(one), 2)))
|
|
a[0] = zero
|
|
a[1] = itor(1)
|
|
a[2] = zero
|
|
a[3] = i2tor(1,3)
|
|
a[4] = zero
|
|
a[5] = i2tor(2,15)
|
|
a[6] = zero
|
|
a[7] = i2tor(17,315)
|
|
a[8] = zero
|
|
a[9] = i2tor(62,2835)
|
|
checka(t, a, "Tan") // 0 1 0 1/3 0 2/15
|
|
*/
|
|
}
|
|
}
|