// String returns all the lines in one String, separated by '\n'
963337
func (ml *MemoryLogger) String() string {
	buf := new(bytes.Buffer)
	ml.mu.Lock()
	defer ml.mu.Unlock()
	for _, event := range ml.Events {
		EventToBuffer(event, buf)
		buf.WriteByte('\n')
	}
	return buf.String()
}
1196187
func (s *SeqExpr) String() string {
	var buf bytes.Buffer

	buf.WriteString(fmt.Sprintf("%s: %T{Exprs: [\n", s.p, s))
	for _, e := range s.Exprs {
		buf.WriteString(fmt.Sprintf("%s,\n", e))
	}
	buf.WriteString("]}")
	return buf.String()
}
920861
func (r *Row) String() string {
	// get the max number of lines for each cell
	var lc int // line count
	for _, cell := range r.Cells {
		if clc := len(strings.Split(cell.String(), "\n")); clc > lc {
			lc = clc
		}
	}

	// allocate a two-dimentional array of cells for each line and add size them
	cells := make([][]*Cell, lc)
	for x := 0; x < lc; x++ {
		cells[x] = make([]*Cell, len(r.Cells))
		for y := 0; y < len(r.Cells); y++ {
			cells[x][y] = &Cell{Width: r.Cells[y].Width}
		}
	}

	// insert each line in a cell as new cell in the cells array
	for y, cell := range r.Cells {
		lines := strings.Split(cell.String(), "\n")
		for x, line := range lines {
			cells[x][y].Data = line
		}
	}

	// format each line
	lines := make([]string, lc)
	for x := range lines {
		line := make([]string, len(cells[x]))
		for y := range cells[x] {
			line[y] = cells[x][y].String()
		}
		lines[x] = strutil.Join(line, r.Separator)
	}
	return strutil.Join(lines, "\n")
}
1308405
func (g *Group) String() *Statement {
	// notest
	s := String()
	g.items = append(g.items, s)
	return s
}
1050075
func (b *ByteBuffer) String() string {
	b.Lock()
	defer b.Unlock()
	return b.b.String()
}
242860
func (m *Matrix) String() string {
	buffer := bytes.NewBuffer(nil)
	rows, cols := m.Size()

	for row := 0; row < rows; row++ {
		for col := 0; col < cols; col++ {
			buffer.WriteString(f64s(m.Get(row, col)))
			buffer.WriteRune(' ')
		}
		buffer.WriteRune('\n')
	}
	return buffer.String()
}
1354778
func (p Path) String() string {
	names := make([]string, 0, len(p.Path))
	for _, node := range p.Path {
		names = append(names, node.Name)
	}
	return strings.Join(names, "/")
}
841926
func (f *File) String() string {
	src, _ := ioutil.ReadAll(f)
	f.Reader = bytes.NewReader(src)
	return string(src)
}
774540
func (n *Network) String() string {
	var buf bytes.Buffer
	var biases bytes.Buffer

	for i := 0; i < n.size; i++ {
		for j := 0; j < n.size; j++ {
			v := n.weights.At(j, i)
			if math.Abs(v) > 0 {
				buf.WriteString(fmt.Sprintf("\t(%d %d %.2f)\n", i+1, j+1, v))
			}
		}
	}

	for _, v := range n.biases {
		biases.WriteString(fmt.Sprintf(" %.2f", v))
	}

	return fmt.Sprintf("Network(%d, %s, %s)", n.size, biases.String(), buf.String())
}
621077
func (ls LineString) String() string {
	var result string
	if bytes, err := json.Marshal(ls); err == nil {
		result = string(bytes)
	} else {
		result = err.Error()
	}
	return result
}
401089
func (l *Literal) String() string {
	return fmt.Sprintf("\"%v\"^^type:%v", l.Interface(), l.Type())
}
1108673
func String(v interface{}, options ...Option) string {
	w := bytes.NewBuffer(nil)
	options = append([]Option{NoIndent()}, options...)
	p := New(w, options...)
	p.Print(v)
	return w.String()
}
1030281
func (sheet *Stylesheet) String() string {
	result := ""

	for _, rule := range sheet.Rules {
		if result != "" {
			result += "\n"
		}
		result += rule.String()
	}

	return result
}
1286937
func (f *File) String() string {
	return fmt.Sprintf("ParamName: %v; FileName: %v", f.ParamName, f.Name)
}
1302083
func (i *Identifier) String() string {
	if i.Unquoted != nil {
		return *i.Unquoted
	}
	return string(*i.Quoted)
}
974027
func (c *ContextError) String() string {
	return fmt.Sprintf("(%d) %s", c.Code, c.Err)
}
435841
func (vec *T) String() string {
	return fmt.Sprint(vec[0], vec[1], vec[2], vec[3])
}