func main() {
screen_width := 1280;
screen_height := 720;
benchmark_mode := false; // true -> loop 50 times to benchmark
canvas := canvas.EmptyCanvasImage(screen_width, screen_height, canvas.Color32(0xff000000));
g := new(gyu3d.G3DContext);
g.SetViewport(gyu3d.StandardViewport(screen_width, screen_height));
g.SetProjection(
gyu3d.IdentityM44().SetPerspective(float(screen_width)*0.006, float(screen_height)*0.006, 1.8, 100.0)
);
lx, ly := .1, -0.3;
if len(flag.Args()) == 2 {
lx, _ = strconv.Atof(flag.Args()[0]);
ly, _ = strconv.Atof(flag.Args()[1]);
}
g.ResetTransforms();
g.ViewMatrix.LookAt(0,1,0, -1.2,1.9,7, -0.5,0.9,0);
g.Update();
// draw
drawTestScene(canvas, g, lx, ly, benchmark_mode);
// export image
outfile,e := file.WritableFile("./out.png");
if e == nil {
png.Encode(outfile, canvas);
outfile.Close();
}
fmt.Printf("done\n");
}
func parseBranchLength(pi ParserInput, pos int) (float, int) {
pos = skipWhitespace(pi, pos)
// expect + consume ':'
if pi.CharAt(pos) != ':' {
//throw new RuntimeException("parse error: parseBranchLength expects ':' at " + ptr);
return 0.0, 0
} else {
pos++
pos = skipWhitespace(pi, pos)
flen := findFloat(pi, pos)
if flen == pos {
fmt.Printf("error: missing float number at %d\n", pos)
}
blen, _ := strconv.Atof(pi.Substring(pos, flen))
pos = flen
return blen, pos
}
panic("unreachable")
}
func (this *Lexicon) Analyze() {
tokenizer := strutils.NewStrTokens(this.buffer.String())
outer:
for tokenizer.HasMoreTokens() {
token := tokenizer.NextToken()
//keywords, separators, operators, literals, identifiers
for _, k := range keywords {
if k == token {
this.keywords.Push(token)
continue outer
}
}
for _, s := range separators {
if s == token {
this.separators.Push(token)
continue outer
}
}
for _, o := range operators {
if o == token {
this.operators.Push(token)
continue outer
}
}
//check if literal
_, err := strconv.Atof(token)
if err == nil {
this.literals.Push(token)
continue outer
}
//if it reaches here, then it is an identifier
this.identifiers.Push(token)
}
}
// Find the best match for a given mime-type against
// a list of media_ranges that have already been
// parsed by ParseMediaRange(). Returns a tuple of
// the fitness value and the value of the 'q' quality
// parameter of the best match, or (-1, 0) if no match
// was found. Just as for QualityParsed(), 'parsedranges'
// must be a list of parsed media ranges.
func FitnessAndQuality(mimetype string, parsedRanges []Mime) (fitness int, quality float) {
bestfitness := -1
bestquality := 0.0
target, _ := ParseMediaRange(mimetype)
for _, r := range parsedRanges {
pmatches := 0
fitness := 0
if (r.mtype == target.mtype || r.mtype == "*" || target.mtype == "*") &&
(r.subtype == target.subtype || r.subtype == "*" || target.subtype == "*") {
fitness += 1
for key, targetvalue := range target.params {
if key != "q" {
if value, ok := r.params[key]; ok && value == targetvalue {
pmatches++
}
}
}
fitness += pmatches
if r.subtype == target.subtype {
fitness += 10
}
if r.mtype == target.mtype {
fitness += 100
}
if fitness > bestfitness {
bestfitness = fitness
bestquality, _ = strconv.Atof(r.params["q"])
}
}
}
return bestfitness, bestquality
}
func (this *Section) F(key string, defval float) float {
if v, ok := this.Pairs[key]; ok {
if f, err := strconv.Atof(v); err == nil {
return f
}
}
return defval
}
// GetFloat has the same behaviour as GetString but converts the response to float.
func (c *ConfigFile) GetFloat(section string, option string) (value float, err os.Error) {
sv, err := c.GetString(section, option)
if err == nil {
value, err = strconv.Atof(sv)
}
return value, err
}
// Parsuje parametr znajdujacy sie na poczatku frag. Pomija biale znaki przed
// parametrem i usuwa za nim (po wywolaniu frag[0] nie jest bialym znakiem).
func parse1Param(txt *string, lnum *int) (
par interface{}, err os.Error) {
frag := *txt
// Pomijamy biale znaki, ktore moga wystapic przed parametrem.
err = skipWhite(&frag, lnum)
if err != nil {
return
}
if frag[0] == '"' || frag[0] == '\'' {
// Parametrem jest tekst.
txt_sep := frag[0:1]
frag = frag[1:]
if len(frag) == 0 {
err = ParseErr{*lnum, PARSE_UNEXP_EOF}
return
}
// Parsujemy tekst parametru.
par, err = parse1(&frag, lnum, txt_sep)
if err != nil {
return
}
} else if uni.IsDigit(int(frag[0])) ||
str.IndexRune(seps_num, int(frag[0])) != -1 {
// Parametrem jest liczba
ii := findChar(frag, seps_nnum, lnum)
if ii == -1 {
err = ParseErr{*lnum, PARSE_UNEXP_EOF}
return
}
var iv int
iv, err = strconv.Atoi(frag[0:ii])
if err != nil {
var fv float
fv, err = strconv.Atof(frag[0:ii])
if err != nil {
err = ParseErr{*lnum, PARSE_BAD_FLOINT}
return
}
par = reflect.NewValue(fv)
} else {
par = reflect.NewValue(iv)
}
frag = frag[ii:]
} else {
par, err = parse1VarFun("", &frag, lnum, false)
if err != nil {
return
}
}
// Pomijamy biale znaki, ktore moga wystapic po parametrze.
err = skipWhite(&frag, lnum)
*txt = frag
return
}
func (d DoubleValue) LoadXML(p *xml.Parser) (ParamValue, os.Error) {
val, er := readBody(p)
if er != nil {
return nil, er
}
tempDouble, err := strconv.Atof(val)
d = DoubleValue(tempDouble)
return d, err
}
// Carves up a media range and returns a tuple of the
// (type, subtype, params) where 'params' is a dictionary
// of all the parameters for the media range.
// For example, the media range 'application/*;q=0.5' would
// get parsed into:
//
// ('application', '*', {'q', '0.5'})
//
// In addition this function also guarantees that there
// is a value for 'q' in the params dictionary, filling it
// in with a proper default if necessary.
func ParseMediaRange(mediarange string) (mime Mime, err os.Error) {
parsed, err := ParseMimeType(mediarange)
if err != nil {
return parsed, err
}
if q, ok := parsed.params["q"]; ok {
if val, err := strconv.Atof(q); err != nil || val > 1.0 || val < 0.0 {
parsed.params["q"] = "1"
}
} else {
parsed.params["q"] = "1"
}
return parsed, nil
}
func readFloat(r io.Reader) (float, os.Error) {
bits, err := ioutil.ReadAll(io.LimitReader(r, 31))
if err != nil {
return 0, err
}
// Atof doesn't like trailing 0s
var i int
for i = 0; i < len(bits); i++ {
if bits[i] == 0 {
break
}
}
return strconv.Atof(string(bits[0:i]))
}
func f_numify(v *Any) *Any {
switch i := (*v).(type) {
case nil:
return i_0
case Undef:
return i_0
case Int:
return v
case Num:
return v
case Str:
// Str can be converted to Int or Num
s := string((*v).(Str))
out := ""
pos := 0
max := len(s)
if pos >= max {
return i_0
}
if s[pos] == '+' {
pos++
} else if s[pos] == '-' {
out += s[pos : pos+1]
pos++
}
if pos >= max || s[pos] < '0' || s[pos] > '9' {
return i_0
}
for i := pos; i < len(s); i++ {
if s[i] >= '0' && s[i] <= '9' {
out += s[i : i+1]
pos++
} else {
i = len(s)
}
}
if (pos < max && s[pos] == '.') || ((pos+1) < max && (s[pos] == 'e' || s[pos] == 'E') && (s[pos+1] == '+' || s[pos+1] == '-' || (s[pos+1] >= '0' && s[pos+1] <= '9'))) {
// 123. 123e10
n, _ := strconv.Atof(s)
return toNum(n)
}
n, _ := strconv.Atoi(out)
return toInt(n)
}
return (*v).(int_er).f_int(Capture{})
}
// Find and evaluate a factor
func getFactor() float {
if digitCheck, _ := regexp.MatchString("[0-9]+(\\.[0-9]+)?", input[0]); digitCheck {
res, _ := strconv.Atof(input[0])
pop()
return res
} else if input[0] == "(" {
pop()
res := getExpr()
if input[0] != ")" {
doerror("No closing parenthesis")
}
pop()
return res
} else {
doerror(fmt.Sprintf("Misplaced element %s, check syntax", input[0]))
}
return 0
}
func processRow(row string) (d StockData, err os.Error) {
rowParts := strings.Split(row, ",", -1)
d.date = rowParts[0]
var tmp float
tmp, err = strconv.Atof(rowParts[4])
if err != nil {
return
}
d.close = tmp
var tmpInt int
tmpInt, err = strconv.Atoi(rowParts[5])
if err != nil {
return
}
d.volume = tmpInt
return d, nil
}
func (f *floatValue) set(s string) bool {
v, err := strconv.Atof(s)
*f.p = v
return err == nil
}
func (f *floatValue) Set(s string) bool {
v, err := strconv.Atof(s)
*f = floatValue(v)
return err == nil
}
func main() {
flag_help := flag.Bool("help", false, "display this help")
flag_infile := flag.String("in", "",
`input file with data. Each row is a data point. First number in
every line must be 1 or -1 and means point class. Next float numbers
are point coordinates.`)
flag.Parse()
if *flag_help {
flag.PrintDefaults()
return
}
// configuring input file
infile := os.Stdin
var err os.Error
if *flag_infile != "" {
infile, err = os.Open(*flag_infile, os.O_RDONLY, 0000)
if err != nil {
panic(err)
}
}
// reading data
points := make([][]float, 1, 10)
target := make([]float, 1, 10)
{
reader := bufio.NewReader(infile)
// reading first line
dimentions := 0
var err os.Error
var line string
line, err = reader.ReadString('\n')
line = strings.Trim(line, " \t\n")
chunks := strings.Split(line, "\t", -1)
if len(chunks) < 3 {
panic("Too small numbers in a line")
}
target[0], err = strconv.Atof(chunks[0])
if err != nil {
panic(err)
}
dimentions = len(chunks) - 1
points[0] = make([]float, dimentions)
for i := 1; i < len(chunks); i++ {
points[0][i-1], err = strconv.Atof(chunks[i])
if err != nil {
panic(err)
}
}
// reading other points
line, err = reader.ReadString('\n')
for err == nil || err == os.EOF {
line = strings.Trim(line, " \t\n")
if line == "" {
if err == os.EOF {
break
}
line, err = reader.ReadString('\n')
continue
}
chunks := strings.Split(line, "\t", -1)
if len(chunks)-1 != dimentions {
panic("Dimentions mismatch.")
}
if len(points)+1 >= cap(points) {
// resize arrays
{
tmp := make([][]float, len(points), 2*len(points))
copy(tmp, points)
points = tmp
}
{
tmp := make([]float, len(points), 2*len(points))
copy(tmp, target)
target = tmp
}
}
pos := len(points)
points = points[0 : len(points)+1]
target = target[0 : len(points)+1]
target[pos], err = strconv.Atof(chunks[0])
if err != nil {
panic(err)
}
points[pos] = make([]float, dimentions)
for i := 1; i < len(chunks); i++ {
points[pos][i-1], err = strconv.Atof(chunks[i])
if err != nil {
panic(err)
}
}
if err == os.EOF {
break
}
line, err = reader.ReadString('\n')
}
if err != nil && err != os.EOF {
panic(err)
}
}
size := len(points)
C := 5.0
fmt.Println("Classification started for size", size)
numChanged := 0
examineAll := true
alpha := make([]float, size)
itersCnt := 0
for (numChanged > 0) || examineAll {
itersCnt++
numChanged = 0
if examineAll {
for i, _ := range points {
numChanged += examineExample(points, target, C, alpha, i)
}
} else {
for i, a := range alpha {
if a == 0.0 || a == C {
continue
}
numChanged += examineExample(points, target, C, alpha, i)
}
}
if examineAll {
examineAll = false
} else if numChanged == 0 {
examineAll = true
}
}
w, w0 := makeClassificateVector(points, target, alpha)
errors := 0
for i := 0; i < len(points)/2; i++ {
if prod(w, points[i])-w0 >= 0 {
errors++
}
}
for i := len(points) / 2; i < len(points); i++ {
if prod(w, points[i])-w0 <= 0 {
errors++
}
}
if errors > 0 {
for i, p := range points {
fmt.Println(i, prod(w, p)-w0)
}
}
fmt.Println("w =", w)
fmt.Println("w0 =", w0)
fmt.Println("iters =", itersCnt)
fmt.Println("errors =", errors, " /", len(points), " =", float(errors)/float(len(points))*100.0, "%")
}
func ReadPoints(f io.Reader) (points [][]float, target []float) {
points = make([][]float, 1, 10)
target = make([]float, 1, 10)
reader := bufio.NewReader(f)
// reading first line
dimentions := 0
var err os.Error
var line string
line, err = reader.ReadString('\n')
line = strings.Trim(line, " \t\n")
chunks := strings.Split(line, "\t", -1)
if len(chunks) < 3 {
panic("Too small numbers in a first line.")
}
target[0], err = strconv.Atof(chunks[0])
if err != nil {
panic(err)
}
dimentions = len(chunks) - 1
points[0] = make([]float, dimentions)
for i := 1; i < len(chunks); i++ {
points[0][i-1], err = strconv.Atof(chunks[i])
if err != nil {
panic(err)
}
}
// reading other points
line, err = reader.ReadString('\n')
for err == nil || err == os.EOF {
line = strings.Trim(line, " \t\n")
if line == "" {
if err == os.EOF {
break
}
line, err = reader.ReadString('\n')
continue
}
chunks := strings.Split(line, "\t", -1)
if len(chunks)-1 != dimentions {
panic("Dimentions mismatch.")
}
if len(points)+1 >= cap(points) {
// resize arrays
{
tmp := make([][]float, len(points), 2*len(points))
copy(tmp, points)
points = tmp
}
{
tmp := make([]float, len(target), 2*len(target))
copy(tmp, target)
target = tmp
}
}
pos := len(points)
points = points[0 : len(points)+1]
target = target[0 : len(target)+1]
target[pos], err = strconv.Atof(chunks[0])
if err != nil {
panic(err)
}
points[pos] = make([]float, dimentions)
for i := 1; i < len(chunks); i++ {
points[pos][i-1], err = strconv.Atof(chunks[i])
if err != nil {
panic(err)
}
}
if err == os.EOF {
break
}
line, err = reader.ReadString('\n')
}
if err != nil && err != os.EOF {
panic(err)
}
return
}
// TODO: Write tests for the arg checking
func (obj *GTPObject) ExecuteCommand(input string) (result string, quit bool, err Error) {
empty, hasId, id, commandName, args := obj.parseLine(input)
if empty {
return "", false, nil
}
gtpCmd, ok := obj.commands[commandName]
if !ok { // This command is not found
return obj.formatErrorResponse(hasId, id, "unknown command"), false, nil
}
// Check the arguments
signatureLen := len(gtpCmd.Signature)
if signatureLen != len(args) {
return obj.formatErrorResponse(hasId, id, fmt.Sprintf("wrong number of arguments, %d argument(s) expected", signatureLen)), false, nil
}
argsToPass := make([]interface{}, len(args))
for i := 0; i < len(args); i++ {
// TODO: refactor this!
// TODO: Do the type conversion (e.g. gtpVertexToPoint) here
switch gtpCmd.Signature[i] {
case GTPBool:
if args[i] != "true" || args[i] != "false" {
errmsg := fmt.Sprintf("argument %d has to be a boolean", i)
return obj.formatErrorResponse(hasId, id, errmsg), false, nil
} else {
val := true
if args[i] == "false" {
val = false
}
argsToPass[i] = val
}
case GTPColor:
color, ok := gtpColorToColor(args[i])
if !ok {
errmsg := fmt.Sprintf("argument %d has to be a color", i)
return obj.formatErrorResponse(hasId, id, errmsg), false, nil
} else {
argsToPass[i] = color
}
case GTPFloat:
fval, err := strconv.Atof(args[i])
if err != nil {
errmsg := fmt.Sprintf("argument %d has to be a float", i)
return obj.formatErrorResponse(hasId, id, errmsg), false, nil
} else {
argsToPass[i] = fval
}
case GTPInt:
ival, err := strconv.Atoui(args[i])
if err != nil {
errmsg := fmt.Sprintf("argument %d has to be an unsigned int", i)
return obj.formatErrorResponse(hasId, id, errmsg), false, nil
} else {
argsToPass[i] = ival
}
case GTPVertex:
point, ok, pass := gtpVertexToPoint(args[i])
if !ok {
errmsg := fmt.Sprintf("argument %d has to be a vertex", i)
return obj.formatErrorResponse(hasId, id, errmsg), false, nil
} else {
//fmt.Printf("ExecuteCommand: point: %v\n", point)
argsToPass[i] = *NewVertex(point, pass)
}
case GTPString:
argsToPass[i] = args[i]
default:
// This should never happen
panic("\n\nThe signature of " + commandName + " is set erroneous.\n\n")
}
}
cmdResponse, retQuit, err := gtpCmd.Func(obj, argsToPass)
if err != nil {
return obj.formatErrorResponse(hasId, id, cmdResponse), retQuit, nil
}
return obj.formatSuccessResponse(hasId, id, cmdResponse), retQuit, nil
}
// literal consumes a literal from d.data[d.off-1:], decoding into the value v.
// The first byte of the literal has been read already
// (that's how the caller knows it's a literal).
func (d *decodeState) literal(v reflect.Value) {
// All bytes inside literal return scanContinue op code.
start := d.off - 1
op := d.scanWhile(scanContinue)
// Scan read one byte too far; back up.
d.off--
d.scan.undo(op)
item := d.data[start:d.off]
// Check for unmarshaler.
wantptr := item[0] == 'n' // null
unmarshaler, pv := d.indirect(v, wantptr)
if unmarshaler != nil {
err := unmarshaler.UnmarshalJSON(item)
if err != nil {
d.error(err)
}
return
}
v = pv
switch c := item[0]; c {
case 'n': // null
switch v.(type) {
default:
d.saveError(&UnmarshalTypeError{"null", v.Type()})
case *reflect.InterfaceValue, *reflect.PtrValue, *reflect.MapValue:
v.SetValue(nil)
}
case 't', 'f': // true, false
value := c == 't'
switch v := v.(type) {
default:
d.saveError(&UnmarshalTypeError{"bool", v.Type()})
case *reflect.BoolValue:
v.Set(value)
case *reflect.InterfaceValue:
v.Set(reflect.NewValue(value))
}
case '"': // string
s, ok := unquote(item)
if !ok {
d.error(errPhase)
}
switch v := v.(type) {
default:
d.saveError(&UnmarshalTypeError{"string", v.Type()})
case *reflect.StringValue:
v.Set(s)
case *reflect.InterfaceValue:
v.Set(reflect.NewValue(s))
}
default: // number
if c != '-' && (c < '0' || c > '9') {
d.error(errPhase)
}
s := string(item)
switch v := v.(type) {
default:
d.error(&UnmarshalTypeError{"number", v.Type()})
case *reflect.InterfaceValue:
n, err := strconv.Atof64(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(reflect.NewValue(n))
case *reflect.IntValue:
n, err := strconv.Atoi(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Int8Value:
n, err := strconv.Atoi(s)
if err != nil || int(int8(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int8(n))
case *reflect.Int16Value:
n, err := strconv.Atoi(s)
if err != nil || int(int16(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int16(n))
case *reflect.Int32Value:
n, err := strconv.Atoi(s)
if err != nil || int(int32(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int32(n))
case *reflect.Int64Value:
n, err := strconv.Atoi64(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.UintValue:
n, err := strconv.Atoui(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Uint8Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint8(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint8(n))
case *reflect.Uint16Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint16(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint16(n))
case *reflect.Uint32Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint32(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint32(n))
case *reflect.Uint64Value:
n, err := strconv.Atoui64(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.UintptrValue:
n, err := strconv.Atoui64(s)
if err != nil || uint64(uintptr(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uintptr(n))
case *reflect.FloatValue:
n, err := strconv.Atof(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Float32Value:
n, err := strconv.Atof32(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Float64Value:
n, err := strconv.Atof64(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
}
}
}
func writeTo(data []byte, val reflect.Value) os.Error {
s := string(data)
switch v := val.(type) {
// if we're writing to an interace value, just set the byte data
// TODO: should we support writing to a pointer?
case *reflect.InterfaceValue:
v.Set(reflect.NewValue(data))
case *reflect.BoolValue:
b, err := strconv.Atob(s)
if err != nil {
return err
}
v.Set(b)
case *reflect.IntValue:
i, err := strconv.Atoi(s)
if err != nil {
return err
}
v.Set(i)
case *reflect.Int8Value:
i, err := strconv.Atoi(s)
if err != nil {
return err
}
v.Set(int8(i))
case *reflect.Int16Value:
i, err := strconv.Atoi(s)
if err != nil {
return err
}
v.Set(int16(i))
case *reflect.Int32Value:
i, err := strconv.Atoi(s)
if err != nil {
return err
}
v.Set(int32(i))
case *reflect.Int64Value:
i, err := strconv.Atoi64(s)
if err != nil {
return err
}
v.Set(i)
case *reflect.UintValue:
ui, err := strconv.Atoui(s)
if err != nil {
return err
}
v.Set(ui)
case *reflect.Uint8Value:
ui, err := strconv.Atoui(s)
if err != nil {
return err
}
v.Set(uint8(ui))
case *reflect.Uint16Value:
ui, err := strconv.Atoui(s)
if err != nil {
return err
}
v.Set(uint16(ui))
case *reflect.Uint32Value:
ui, err := strconv.Atoui(s)
if err != nil {
return err
}
v.Set(uint32(ui))
case *reflect.Uint64Value:
ui, err := strconv.Atoui64(s)
if err != nil {
return err
}
v.Set(ui)
case *reflect.UintptrValue:
ui, err := strconv.Atoui64(s)
if err != nil {
return err
}
v.Set(uintptr(ui))
case *reflect.FloatValue:
f, err := strconv.Atof(s)
if err != nil {
return err
}
v.Set(f)
case *reflect.Float32Value:
f, err := strconv.Atof32(s)
if err != nil {
return err
}
v.Set(f)
case *reflect.Float64Value:
f, err := strconv.Atof64(s)
if err != nil {
return err
}
v.Set(f)
case *reflect.StringValue:
v.Set(s)
case *reflect.SliceValue:
typ := v.Type().(*reflect.SliceType)
if _, ok := typ.Elem().(*reflect.Uint8Type); ok {
v.Set(reflect.NewValue(data).(*reflect.SliceValue))
}
}
return nil
}
func (s *Stmt) Scan(args ...interface{}) os.Error {
n := int(C.sqlite3_column_count(s.stmt))
if n != len(args) {
return os.NewError("incorrect argument count")
}
for i, v := range args {
n := C.sqlite3_column_bytes(s.stmt, C.int(i))
p := C.sqlite3_column_blob(s.stmt, C.int(i))
if p == nil && n > 0 {
return os.NewError("got nil blob")
}
var data []byte
if n > 0 {
// fix(jimt): Must make a copy here. Once Stmt.Finalize() is called,
// this memory becomes invalid. This was done on purpose according
// to Russ: http://code.google.com/p/gosqlite/issues/detail?id=1
// I prefer it with the copy statement here. Behaviour otherwise is
// misleading and cost me 3 hours of hair pulling.
data = make([]byte, n)
copy(data, (*[1<<31 - 1]byte)(unsafe.Pointer(p))[0:n])
}
switch v := v.(type) {
case *[]byte:
*v = data
case *string:
*v = string(data)
case *bool:
*v = string(data) == "1"
case *int:
x, err := strconv.Atoi(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = x
case *int8:
x, err := strconv.Atoi(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = int8(x)
case *int16:
x, err := strconv.Atoi(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = int16(x)
case *int32:
x, err := strconv.Atoi(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = int32(x)
case *int64:
x, err := strconv.Atoi64(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int64: " + err.String())
}
*v = x
case *uint:
x, err := strconv.Atoui(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = x
case *uint8:
x, err := strconv.Atoui(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = uint8(x)
case *uint16:
x, err := strconv.Atoui(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = uint16(x)
case *uint32:
x, err := strconv.Atoui(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
}
*v = uint32(x)
case *uint64:
x, err := strconv.Atoui64(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int64: " + err.String())
}
*v = x
case *float:
x, err := strconv.Atof(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as float64: " + err.String())
}
*v = x
case *float32:
x, err := strconv.Atof32(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as float64: " + err.String())
}
*v = x
case *float64:
x, err := strconv.Atof64(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as float64: " + err.String())
}
*v = x
default:
return os.NewError("unsupported type in Scan: " + reflect.Typeof(v).String())
}
}
return nil
}
func (vm *NgaroVM) core(ip int) {
var port [nports]int
var sp, rsp int
var tos int
var data, addr [stackDepth + 2]int
sp = 2 // to avoid underflows
defer func() {
if v := recover(); v != nil {
if err, ok := v.(os.Error); ok {
vm.Err <- err
} else {
vm.Err <- os.NewError("unknown error:" + fmt.Sprint(v))
}
}
}()
for ; ip < len(vm.img); ip++ {
switch vm.img[ip] {
case Nop:
case Lit:
sp++
ip++
data[sp] = vm.img[ip]
case Dup:
sp++
data[sp] = tos
case Drop:
sp--
case Swap:
data[sp], data[sp-1] = data[sp-1], tos
case Push:
rsp++
addr[rsp] = tos
sp--
case Pop:
sp++
data[sp] = addr[rsp]
rsp--
case Call:
ip++
rsp++
addr[rsp] = ip
ip = vm.img[ip] - 1
case Jump:
ip++
ip = vm.img[ip] - 1
case Return:
ip = addr[rsp]
rsp--
case GtJump:
ip++
if data[sp-1] > tos {
ip = vm.img[ip] - 1
}
sp = sp - 2
case LtJump:
ip++
if data[sp-1] < tos {
ip = vm.img[ip] - 1
}
sp = sp - 2
case NeJump:
ip++
if data[sp-1] != tos {
ip = vm.img[ip] - 1
}
sp = sp - 2
case EqJump:
ip++
if data[sp-1] == tos {
ip = vm.img[ip] - 1
}
sp = sp - 2
case Fetch:
data[sp] = vm.img[tos]
case Store:
vm.img[tos] = data[sp-1]
sp = sp - 2
case Add:
data[sp-1] += tos
sp--
case Sub:
data[sp-1] -= tos
sp--
case Mul:
data[sp-1] *= tos
sp--
case Dinod:
data[sp] = data[sp-1] / tos
data[sp-1] = data[sp-1] % tos
case And:
data[sp-1] &= tos
sp--
case Or:
data[sp-1] |= tos
sp--
case Xor:
data[sp-1] ^= tos
sp--
case ShL:
data[sp-1] <<= uint(tos)
sp--
case ShR:
data[sp-1] >>= uint(tos)
sp--
case ZeroExit:
if tos == 0 {
sp--
ip = addr[rsp]
rsp--
}
case Inc:
data[sp]++
case Dec:
data[sp]--
case In:
data[sp] = port[tos]
port[tos] = 0
case Out:
port[0] = 0
port[tos] = data[sp-1]
sp = sp - 2
case Wait:
sp -= vm.wait(&port, tos, sp, rsp, data[0:])
case FP + GtJump:
ip++
if itof(data[sp-1]) > itof(tos) {
ip = vm.img[ip] - 1
}
sp = sp - 2
case FP + LtJump:
ip++
if itof(data[sp-1]) < itof(tos) {
ip = vm.img[ip] - 1
}
sp = sp - 2
case FP + Add:
data[sp-1] = ftoi(itof(data[sp-1]) + itof(tos))
sp--
case FP + Sub:
data[sp-1] = ftoi(itof(data[sp-1]) - itof(tos))
sp--
case FP + Mul:
data[sp-1] = ftoi(itof(data[sp-1]) * itof(tos))
sp--
case FP + Dinod:
data[sp-1] = ftoi(itof(data[sp-1]) / itof(tos))
sp--
// TODO: more math operations
case IOint + In:
a := readA(vm.img, tos)
sp++
if i, err := strconv.Atoi(a); err != nil {
data[sp] = 0
} else {
data[sp-1] = i
data[sp] = -1
}
case IOint + Out:
fmt.Fprint(vm.Output, tos)
sp--
case IOfloat + In:
a := readA(vm.img, tos)
sp++
if f, err := strconv.Atof(a); err != nil {
data[sp] = 0
} else {
data[sp-1] = ftoi(f)
data[sp] = -1
}
case IOfloat + Out:
fmt.Fprint(vm.Output, itof(tos))
sp--
case IOstring + In: // Accept
var c [1]byte
var cont func() bool
if data[sp-1] == -1 {
cont = func() bool { return c[0] != ' ' && c[0] != '\n' && c[0] != '\t' }
} else {
cont = func() bool { return c[0] != byte(data[sp-1]) }
}
a := tos
readInput:
_, err := vm.Input.Read(c[0:])
// Skip leading white-space
for data[sp-1] == -1 && (c[0] == ' ' || c[0] == '\n' || c[0] == '\t') {
vm.Input.Read(c[0:])
}
for ; err == nil && cont(); _, err = vm.Input.Read(c[0:]) {
vm.img[a] = int(c[0])
a++
}
if err == os.EOF && vm.Input != nil {
vm.Input.Close()
vm.Input = vm.Input.Next
goto readInput
}
if err != nil {
panic(err)
}
vm.img[a] = 0
sp -= 2
case IOstring + Out:
i := tos
for ; i < len(vm.img) && vm.img[i] != 0; i++ {
}
fmt.Fprint(vm.Output, string(vm.img[tos:i]))
sp--
default:
rsp++
addr[rsp] = ip
ip = vm.img[ip] - 1
}
// to avoid segfaults:
if sp < 2 {
sp = 2
}
tos = data[sp]
}
}
func (this *Option) Float() float {
if v, err := strconv.Atof(this.value); err == nil {
return v
}
return this.defaultval.(float)
}
expr.Add(peg.Or{
peg.Bind(_INT, func(x interface{}) interface{} {
s := x.(string)
res, err := strconv.Atoi(s)
if err != nil {
num := big.NewInt(0)
_, ok := num.SetString(s, 10)
if !ok {
SystemError(err)
}
return num
}
return res
}),
peg.Bind(_FLOAT, func(x interface{}) interface{} {
res, err := strconv.Atof(x.(string))
if err != nil {
SystemError(err)
}
return res
}),
peg.Bind(_STR, func(x interface{}) interface{} {
res, err := strconv.Unquote(x.(string))
if err != nil {
SystemError(err)
}
return res
}),
listExpr(_LSTART, expr, _LEND),
listExpr(_LSTART2, expr, _LEND2),
peg.Bind(
func parseInnerNode(pi ParserInput, pos int) (*tree.LN, int) {
//fmt.Printf( "parse inner node\n" );
pos = skipWhitespace(pi, pos)
if pi.CharAt(pos) != '(' {
fmt.Printf("error: expected '('\n")
}
// consume opening '('
pos++
var nl *tree.LN
nl, pos = parseNode(pi, pos)
var bll float
bll, pos = parseBranchLength(pi, pos)
// fmt.Printf( "parsing next node %d\n", pos );
var labell string
labell, pos = parseBranchLabel(pi, pos)
pos = skipWhitespace(pi, pos)
// expect + consume ','
if pi.CharAt(pos) != ',' {
fmt.Printf("parse error: parseInnerNode expects ',' at %d\n", pos)
}
pos++
// parse right node + branch length
var nr *tree.LN
nr, pos = parseNode(pi, pos)
var blr float
blr, pos = parseBranchLength(pi, pos)
var labelr string
labelr, pos = parseBranchLabel(pi, pos)
pos = skipWhitespace(pi, pos)
if pi.CharAt(pos) == ',' {
// second comma found: three child nodes == pseudo root
pos++
var nx *tree.LN
nx, pos = parseNode(pi, pos)
var blx float
blx, pos = parseBranchLength(pi, pos)
var labelx string
labelx, pos = parseBranchLabel(pi, pos)
pos = skipWhitespace(pi, pos)
if pi.CharAt(pos) != ')' {
// printLocation();
fmt.Printf("parse error: parseInnerNode (at root) expects ') at %d\n", pos)
}
pos++
pos = skipWhitespace(pi, pos)
n := tree.CreateLN()
twiddle(nl, n.Next, bll, labell, n.Data.Support)
twiddle(nr, n.Next.Next, blr, labelr, n.Data.Support)
twiddle(nx, n, blx, labelx, n.Data.Support)
// fmt.Printf( "twiddle root\n" );
// System.out.printf( "root: %f %f %f\n", nl.data.getSupport(), nr.data.getSupport(), nx.data.getSupport() );
// System.exit(0);
return n, pos
} else if pi.CharAt(pos) == ')' {
// the stuff between the closing '(' and the ':' of the branch length
// is interpreted as node-label. If the node label corresponds to a float value
// it is interpreted as branch support (or node support as a rooted-trees-only-please biologist would say)
pos++
lend := findEndOfBranch(pi, pos)
nodeLabel := pi.Substring(pos, lend)
pos = lend
// fmt.Printf( "pos: %d %s\n", pos, nodeLabel );
isDigit := true
for i := range nodeLabel {
isDigit = isDigit && IsDigit(nodeLabel[i])
if i == 0 {
isDigit = isDigit && (nodeLabel[i] != '0')
}
}
var support float
if isDigit {
support, _ = strconv.Atof(nodeLabel)
} else {
support = -1
}
n := tree.CreateLN()
n.Data.Support = support
//n.data.setNodeLabel(nodeLabel);
twiddle(nl, n.Next, bll, labell, support)
twiddle(nr, n.Next.Next, blr, labelr, support)
return n, pos
} else {
fmt.Printf("parse error: parseInnerNode expects ')'or ',' at %d got: %c\n", pos, pi.CharAt(pos))
return nil, pos
}
panic("unreachable")
}