func main() {
maxSideLength := flag.Float64("max", 1, "maximum side length")
minSideLength := flag.Float64("min", 1, "minimum side length")
flag.Parse()
cuboidStream := make(chan Cuboid, NUM_CONCURRENT_CUBOID_SEARCHES)
perfectCuboid := make(chan Cuboid)
wg := new(sync.WaitGroup)
go waitForPerfectCuboid(perfectCuboid)
go distributeCuboids(cuboidStream, perfectCuboid, wg)
fmt.Printf("Searching for a perfect cuboid with side lengths between %d and %d...", int(*minSideLength), int(*maxSideLength))
x := 1.0
for x <= *maxSideLength {
y := 1.0
for y <= *maxSideLength {
z := 1.0
for z <= *maxSideLength {
if x >= *minSideLength || y >= *minSideLength || z >= *minSideLength {
wg.Add(1)
cuboid := Cuboid{Length: x, Width: y, Height: z}
cuboidStream <- cuboid
}
z += 1
}
y += 1
}
x += 1
}
wg.Wait()
fmt.Println(" done.")
}
func main() {
debug := flag.Bool("debug", false, "debug on")
threaded := flag.Bool("threaded", true, "debug on")
delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.")
branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.")
deldirname := flag.String(
"deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.")
flag.Parse()
if len(flag.Args()) < 2 {
fmt.Println("Usage:\n main MOUNTPOINT RW-DIRECTORY RO-DIRECTORY ...")
os.Exit(2)
}
ufsOptions := unionfs.UnionFsOptions{
DeletionCacheTTLSecs: *delcache_ttl,
BranchCacheTTLSecs: *branchcache_ttl,
DeletionDirName: *deldirname,
}
ufs, err := unionfs.NewUnionFsFromRoots(flag.Args()[1:], &ufsOptions)
if err != nil {
log.Fatal("Cannot create UnionFs", err)
os.Exit(1)
}
mountState, _, err := fuse.MountFileSystem(flag.Arg(0), ufs, nil)
if err != nil {
log.Fatal("Mount fail:", err)
}
mountState.Debug = *debug
mountState.Loop(*threaded)
}
func main() {
// Set up flags.
wFlag := flag.Int("w", 640, "width of the image in pixels")
hFlag := flag.Int("h", 480, "height of the image in pixels")
xMinFlag := flag.Float64("x-min", -2.0, "minimum x value to plot")
xMaxFlag := flag.Float64("x-max", 2.0, "maximum x value to plot")
bailoutFlag := flag.Int("bailout", 100, "maximum iteration bailout")
// Handle the flags.
flag.Parse()
// Main logic.
acc := newAccumulator(*wFlag, *hFlag, *xMinFlag, *xMaxFlag)
const numSamples = 1e8
for acc.getCount() < numSamples {
log.Print(acc.getCount())
accumulateSeqence(*bailoutFlag, acc)
}
img := acc.toImage()
f, err := os.Create("out.png")
if err != nil {
log.Fatal(err)
}
if err := png.Encode(f, img); err != nil {
log.Fatal(err)
}
}
func main() {
drinks := flag.Float64("drinks", 2.5, "How many drinks consumed")
weight := flag.Float64("weight", 70.0, "Body weight in kilograms")
hours := flag.Float64("hours", 2.0, "How many hours it took to drink")
gender := flag.String("gender", "male", "Specify male or female")
flag.Usage = func() {
fmt.Println(`
NAME:
inebriati
DESCRIPTION:
Calculates estimated blood ethanol concentration (EBAC)
COMMANDS:
-drinks Number of standard drinks comsumed.
-weight Weight in kiligrams.
-hours Drinking period in hours.
-gender Select male or female.
`[1:])
}
flag.Parse()
i := inebriati.New(*drinks, *weight, *hours, *gender)
i.Calc()
fmt.Println(i)
}
func main() {
size := flag.Int("psize", 500, "physical size of the square image")
vpx := flag.Float64("x", 0, "x coordinate of the center of the image")
vpy := flag.Float64("y", 0, "y coordinate of the center of the image")
d := flag.Float64("size", 2, "size of the represented part of the plane")
filename := flag.String("name", "image", "name of the image file produced (w/o extension")
numberOfProcs := flag.Int("procs", 2, "number of procs to use")
seed := flag.Int64("seed", 42, "seed for the random number generator")
cols := flag.Bool("with-colors", false, "whether there is colors")
flag.Parse()
runtime.GOMAXPROCS(*numberOfProcs)
withColors = *cols
if *cols {
initColors(*seed)
}
file, err := os.Open(*filename+".png", os.O_RDWR|os.O_CREAT, 0666)
if err != nil {
panic("error with opening file \"" + *filename + "\"")
}
im := image.NewRGBA(*size, *size)
ch := make(chan point, 1000)
Start(im, 2, *vpx, *vpy, *d, ch)
handleChans(im, ch)
png.Encode(file, im)
}
func handleAddConsumer() error {
id := stripArgument()
if id == "" {
return errors.New("No task id supplied to add")
}
var (
api = flag.String("api", "", "API host:port")
cpu = flag.Float64("cpu", 0.1, "CPUs per task")
mem = flag.Float64("mem", 128, "Mem per task")
)
ParseFlags("add")
if err := resolveApi(*api); err != nil {
return err
}
if *executor == "" {
return errors.New("Executor name required")
}
request := framework.NewApiRequest(framework.Config.Api + "/api/add")
request.PutString("type", framework.TaskTypeConsumer)
request.PutString("id", id)
request.PutFloat("cpu", *cpu)
request.PutFloat("mem", *mem)
request.PutString("executor", *executor)
response := request.Get()
fmt.Println(response.Message)
return nil
}
func main() {
diameter := flag.Float64("d", 9.0, "beam diameter in millimetres")
power := flag.Float64("p", 1.0, "laser power in watts")
flag.Parse()
if *diameter <= 0.0 {
fmt.Println("Beam diameter must be a positive number greater than zero.")
return
}
*diameter /= 1000.0 // convert mm to m
ba := beamArea(*diameter)
pd := powerDensity(ba, *power)
od := opticalDensity(pd)
fmt.Printf("Beam area: %f m^2\nPower density: %f W/m^2\n", ba, pd)
if od == -1 {
fmt.Println("Couldn't determine the appropriate optical density rating.")
fmt.Println("Please consult EN207 for the appopriate PPE.")
} else if od == 11 {
fmt.Printf("Your optical density requirements are above the ")
fmt.Printf("standard requirements. Please consult EN207.\n")
} else {
fmt.Printf("Based on your laser's power and beam diameter, ")
fmt.Printf("you should use eyewear with an OD of %d.\n", od)
}
}
func main() {
var data = flag.String("data", "", "The data directory where WOF data lives, required")
var cache_size = flag.Int("cache_size", 1024, "The number of WOF records with large geometries to cache")
var cache_trigger = flag.Int("cache_trigger", 2000, "The minimum number of coordinates in a WOF record that will trigger caching")
var lat = flag.Float64("latitude", 0.0, "")
var lon = flag.Float64("longitude", 0.0, "")
var loglevel = flag.String("loglevel", "info", "...")
flag.Parse()
logger := log.NewWOFLogger("[wof-breaches] ")
logger.AddLogger(os.Stdout, *loglevel)
idx, _ := rtree.NewIndex(*data, *cache_size, *cache_trigger, logger)
for _, path := range flag.Args() {
logger.Info("indexing %s", path)
idx.IndexGeoJSONFile(path)
}
results := idx.GetIntersectsByLatLon(*lat, *lon)
inflated := idx.InflateSpatialResults(results)
for _, r := range inflated {
logger.Info("%v", r)
}
}
func main() {
// do the actual parsing
flag.Var(&listenersFlag, "l", "Which ports to listen on")
flag.Var(&connectorsFlag, "c", "Which addresses to try to connect to")
flag.BoolVar(&infoptr, "v", false, "Turn on verbose mode")
flag.BoolVar(&debugptr, "vv", false, "Turn on extra verbose mode")
retryPeriod = time.Duration(1000 * (*flag.Float64("rp", 5.0,
"Retry rate for double connections")))
connPeriod = time.Duration(1000 * (*flag.Float64("cp", 0.5,
"Retry rate for double connections, on success")))
flag.Parse()
debug("Number of listeners: " + fmt.Sprint(len(listenersFlag)))
debug("Number of connectors: " + fmt.Sprint(len(connectorsFlag)))
// check a possibly temporary condition
if len(listenersFlag)+len(connectorsFlag) != 2 {
errmsg(1, "Strictly 2 connections allowed")
}
if len(listenersFlag) == 1 && len(connectorsFlag) == 1 {
listenOne(normalizeAddr(listenersFlag[0]),
normalizeAddr(connectorsFlag[0]))
}
if len(listenersFlag) == 2 && len(connectorsFlag) == 0 {
listenTwo(normalizeAddr(listenersFlag[0]),
normalizeAddr(listenersFlag[1]))
}
if len(listenersFlag) == 0 && len(connectorsFlag) == 2 {
connectTwo(normalizeAddr(connectorsFlag[0]),
normalizeAddr(connectorsFlag[1]))
}
}
func main() {
count := flag.Int("count", 5, "The number of pings to send")
wait := flag.Float64("wait", 15, "The amount of time to wait for all pings to come back in seconds")
interval := flag.Float64("interval", 2, "The interval to wait between pings in seconds")
repeat := flag.Int("repeat", 30, "Repeat the whole process every x seconds")
socket := flag.String("socket", "/tmp/ping-monitor.sock", "Unix socket to create/listen on")
flag.Parse()
if len(flag.Args()) < 1 {
os.Stderr.WriteString("Must supply at least one IP address!\n")
os.Exit(1)
}
h := &httpmetrics.Handler{
Socket: *socket,
Registries: make(map[string]*metrics.Registry),
}
pi := &PingInfo{
Count: *count,
Wait: *wait,
Interval: *interval,
Repeat: *repeat,
Hosts: flag.Args(),
Registries: &(h.Registries),
}
InitPing(pi)
if err := h.CreateServer(); err != nil {
panic(err)
}
}
func TestParse_Global(t *testing.T) {
resetForTesting("")
os.Setenv(envTestPrefix+"D", "EnvD")
os.Setenv(envTestPrefix+"E", "true")
os.Setenv(envTestPrefix+"F", "5.5")
flagA := flag.Bool("a", false, "")
flagB := flag.Float64("b", 0.0, "")
flagC := flag.String("c", "", "")
flagD := flag.String("d", "", "")
flagE := flag.Bool("e", false, "")
flagF := flag.Float64("f", 0.0, "")
parse(t, "./testdata/global.ini", envTestPrefix)
if !*flagA {
t.Errorf("flagA found %v, expected true", *flagA)
}
if *flagB != 5.6 {
t.Errorf("flagB found %v, expected 5.6", *flagB)
}
if *flagC != "Hello world" {
t.Errorf("flagC found %v, expected 'Hello world'", *flagC)
}
if *flagD != "EnvD" {
t.Errorf("flagD found %v, expected 'EnvD'", *flagD)
}
if !*flagE {
t.Errorf("flagE found %v, expected true", *flagE)
}
if *flagF != 5.5 {
t.Errorf("flagF found %v, expected 5.5", *flagF)
}
}
func main() {
lat := flag.Float64("lat", 0, "latitude of occurrence")
lng := flag.Float64("lng", 0, "longitude of occurrence")
explain := flag.Bool("explain", true, "print useful information")
date := flag.Int64("date", 0, "unix second: 1467558491")
period := flag.Int64("period", 14, "number of days into the past to generate weather: 14")
flag.Parse()
store, err := noaa.NewWeatherStore(
"/Users/mph/Desktop/phenograph-raw-data/stations.txt",
"/Users/mph/Desktop/phenograph-raw-data/ghcnd_all/ghcnd_all",
false,
)
if err != nil {
panic(err)
}
records, err := store.Nearest(
*lat,
*lng,
noaa.Elements{noaa.ElementTMAX, noaa.ElementPRCP, noaa.ElementTMIN},
noaa.TimesFromUnixArray(*date, *period),
*explain,
)
if err != nil {
panic(err)
}
fmt.Println("RECORDS", utils.JsonOrSpew(records))
return
}
func decodeRefArg(name, typeName string) (interface{}, error) {
switch strings.ToLower(typeName) {
case "*bool":
newValue := flag.Bool(name, app.DefaultBoolValue, name)
return newValue, nil
case "bool":
newValue := flag.Bool(name, app.DefaultBoolValue, name)
return *newValue, nil
case "*string":
newValue := flag.String(name, app.DefaultStringValue, name)
return *newValue, nil
case "string":
newValue := flag.String(name, app.DefaultStringValue, name)
return *newValue, nil
case "*time.duration":
newValue := flag.Duration(name, app.DefaultDurationValue, name)
return *newValue, nil
case "time.duration":
newValue := flag.Duration(name, app.DefaultDurationValue, name)
return *newValue, nil
case "*float64":
newValue := flag.Float64(name, app.DefaultFloat64Value, name)
return *newValue, nil
case "float64":
newValue := flag.Float64(name, app.DefaultFloat64Value, name)
return *newValue, nil
case "*int":
newValue := flag.Int(name, app.DefaultIntValue, name)
return *newValue, nil
case "int":
newValue := flag.Int(name, app.DefaultIntValue, name)
return *newValue, nil
case "*int64":
newValue := flag.Int64(name, app.DefaultInt64Value, name)
return *newValue, nil
case "int64":
newValue := flag.Int64(name, app.DefaultInt64Value, name)
return *newValue, nil
case "*uint":
newValue := flag.Uint(name, app.DefaultUIntValue, name)
return *newValue, nil
case "uint":
newValue := flag.Uint(name, app.DefaultUIntValue, name)
return *newValue, nil
case "*uint64":
newValue := flag.Uint64(name, app.DefaultUInt64Value, name)
return *newValue, nil
case "uint64":
newValue := flag.Uint64(name, app.DefaultUInt64Value, name)
return *newValue, nil
}
return nil, fmt.Errorf("unknow type %s for argument %s", typeName, name)
}
func main() {
var seq_file = flag.String("s", "", "Specify a file containing the sequence.")
var rl = flag.Int("l", 100, "Read length.")
var coverage = flag.Float64("c", 2.0, "Coverage")
var error_rate = flag.Float64("e", 0.01, "Error rate.")
flag.BoolVar(&Debug, "debug", false, "Turn on debug mode.")
flag.Parse()
read_len := int(*rl)
if *seq_file != "" {
if *coverage > 0 && read_len > 0 {
idx := fmi.New(*seq_file)
num_of_reads := int(*coverage * float64(idx.LEN) / float64(read_len))
read_indices := make([]int, num_of_reads)
the_read := make([]byte, read_len)
var rand_pos int
for i := 0; i < num_of_reads; i++ {
rand_pos = int(rand_gen.Intn(int(idx.LEN - read_len)))
if justN(rand_pos, int(read_len)) {
i--
continue
}
read_indices = idx.Repeat(rand_pos, read_len)
var errors []int
if int(rand_pos+read_len) >= len(fmi.SEQ) {
panic("Read may be shorter than wanted.")
}
copy(the_read, fmi.SEQ[rand_pos:rand_pos+read_len])
for k := 0; k < len(the_read); k++ {
if rand_gen.Float64() < *error_rate {
the_read[k] = random_error(the_read[k])
errors = append(errors, k)
}
}
if Debug {
for j := 0; j < int(rand_pos); j++ {
fmt.Printf(" ")
}
}
fmt.Printf("%s %d ", the_read, len(read_indices))
for j := 0; j < len(read_indices); j++ {
fmt.Printf("%d ", read_indices[j])
}
fmt.Printf("%d", len(errors))
for j := 0; j < len(errors); j++ {
fmt.Printf(" %d", errors[j])
}
fmt.Println()
}
} else {
idx := fmi.New(*seq_file)
idx.Save(*seq_file)
}
} else {
fmt.Println("Must provide sequence file")
}
}
func main() {
var ohms = flag.Float64("r", 0, "ohms")
var watts = flag.Float64("w", 0, "watts")
var amps = flag.Float64("a", 0, "amps")
var volts = flag.Float64("v", 0, "volts")
flag.Parse()
fmt.Printf("O: %f\tW: %f\tA: %f\tV: %f\n", *ohms, *watts, *amps, *volts)
}
func init() {
img_width = flag.Int("w", 1280, "The width of the resulting image.")
img_height = flag.Int("h", 800, "The height of the resulting image.")
mset_x_ctr = flag.Float64("x", -0.75, "The center of the image with respect to the x-axis of the Mandelbrot Set, between -2.5 and 1.")
mset_y_ctr = flag.Float64("y", 0, "The center of the image with respect to the y-axis of the Mandelbrot Set, between -1 and 1.")
zoom = flag.Float64("z", 1, "Zoom factor.")
max_iterations = flag.Int64("i", 1000, "The number of iterations to perform before considering a coordinate going to infinity.")
}
func parseFlags() (load, blockSize *float64, numBlocks, numIterations *int64) {
load = flag.Float64("load", 0.0, "load percentage")
blockSize = flag.Float64("bs", bls.DEFAULT_BLOCK_SIZE, "block size")
numBlocks = flag.Int64("nb", bls.DEFAULT_NUM_BLOCKS, "number of blocks")
numIterations = flag.Int64("ni", bls.DEFAULT_NUM_ITERATIONS, "number of iterations")
flag.Parse()
return
}
func main() {
var (
width = flag.Int("w", 1024, "width")
top = flag.Int("top", 50, "top")
left = flag.Int("left", 100, "left margin")
vp = flag.Int("vp", 512, "visualization point")
vw = flag.Int("vw", 300, "visual area width")
bh = flag.Int("bh", 20, "bar height")
smax = flag.Float64("sm", 10, "maximum speedup")
dmax = flag.Float64("dm", 100, "maximum delta")
title = flag.String("title", "", "title")
speedcolor = flag.String("scolor", "green", "speedup color")
regresscolor = flag.String("rcolor", "red", "regression color")
style = flag.String("style", "bar", "set the style (bar or inline)")
lines = flag.Bool("line", false, "show lines between entries")
coldata = flag.Bool("col", false, "show data in a single column")
)
flag.Parse()
g := geometry{
width: *width,
top: *top,
left: *left,
vp: *vp,
vwidth: *vw,
barHeight: *bh,
title: *title,
scolor: *speedcolor,
rcolor: *regresscolor,
style: *style,
dolines: *lines,
coldata: *coldata,
speedupmax: *smax,
deltamax: *dmax,
}
// For every named file or stdin, render the SVG in memory, accumulating the height.
var b bytes.Buffer
canvas := svg.New(&b)
height := 0
if len(flag.Args()) > 0 {
for _, f := range flag.Args() {
height = process(canvas, f, g)
g.top = height + 50
}
} else {
height = process(canvas, "", g)
}
g.height = height + 15
// Write the rendered SVG to stdout
out := svg.New(os.Stdout)
out.Start(g.width, g.height)
out.Rect(0, 0, g.width, g.height, "fill:white;stroke-width:2px;stroke:lightgray")
b.WriteTo(os.Stdout)
out.End()
}
func main() {
debug := flag.Bool("debug", false, "debug on")
hardlinks := flag.Bool("hardlinks", false, "support hardlinks")
delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.")
branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.")
deldirname := flag.String(
"deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.")
hide_readonly_link := flag.Bool("hide_readonly_link", true,
"Hides READONLY link from the top mountpoints. "+
"Enabled by default.")
portableInodes := flag.Bool("portable-inodes", false,
"Use sequential 32-bit inode numbers.")
flag.Parse()
if len(flag.Args()) < 2 {
fmt.Println("Usage:\n main MOUNTPOINT BASEDIR")
os.Exit(2)
}
ufsOptions := unionfs.UnionFsOptions{
DeletionCacheTTL: time.Duration(*delcache_ttl * float64(time.Second)),
BranchCacheTTL: time.Duration(*branchcache_ttl * float64(time.Second)),
DeletionDirName: *deldirname,
}
options := unionfs.AutoUnionFsOptions{
UnionFsOptions: ufsOptions,
Options: nodefs.Options{
EntryTimeout: time.Second,
AttrTimeout: time.Second,
NegativeTimeout: time.Second,
Owner: fuse.CurrentOwner(),
},
UpdateOnMount: true,
PathNodeFsOptions: pathfs.PathNodeFsOptions{
ClientInodes: *hardlinks,
},
HideReadonly: *hide_readonly_link,
}
fsOpts := nodefs.Options{
PortableInodes: *portableInodes,
}
gofs := unionfs.NewAutoUnionFs(flag.Arg(1), options)
pathfs := pathfs.NewPathNodeFs(gofs, nil)
state, conn, err := nodefs.MountRoot(flag.Arg(0), pathfs.Root(), &fsOpts)
if err != nil {
fmt.Printf("Mount fail: %v\n", err)
os.Exit(1)
}
pathfs.SetDebug(*debug)
conn.SetDebug(*debug)
state.SetDebug(*debug)
state.Serve()
time.Sleep(1 * time.Second)
}
func main() {
var pv = flag.Float64("pv", 0, "Present Value")
var r = flag.Float64("r", 0, "Interest Rate")
var n = flag.Int("n", 0, "Number of periods")
var c = flag.Bool("c", false, "Compounded Interest")
var d = flag.Int("d", 4, "Digits after the decimal point")
flag.Parse()
f := F.Fee(*pv, *r, *n, *c)
println(strconv.FormatFloat(f, 'f', *d, 64))
}
// Generates the golden files. See test/sounds_test.go for actual test.
func main() {
// Singlethreaded for now...
runtime.GOMAXPROCS(4)
// Parse flags...
sampleRate := s.CyclesPerSecond
minFreq := flag.Float64("minFreq", 110.0, "minimum frequency")
maxFreq := flag.Float64("maxFreq", 14080.0, "maximum frequency")
bpo := flag.Int("bpo", 24, "Buckets per octave")
flag.Parse()
remainingArgs := flag.Args()
if len(remainingArgs) < 1 || len(remainingArgs) > 2 {
panic("Required: <input> [<input>] filename arguments")
}
inputFile := remainingArgs[0]
inputFile2 := inputFile
if len(remainingArgs) == 2 {
inputFile2 = remainingArgs[1]
}
inputSound := f.Read(inputFile)
// inputSound := s.NewTimedSound(s.NewSineWave(440.0), 1000)
inputSound.Start()
defer inputSound.Stop()
// minFreq, maxFreq, bpo := 110.0, 14080.0, 24
params := cq.NewCQParams(sampleRate, *minFreq, *maxFreq, *bpo)
constantQ := cq.NewConstantQ(params)
cqInverse := cq.NewCQInverse(params)
latency := constantQ.OutputLatency + cqInverse.OutputLatency
// Two inputs version - TODO, switch back to input + output.
inputSound2 := f.Read(inputFile2)
inputSound2.Start()
defer inputSound2.Stop()
constantQ2 := cq.NewConstantQ(params)
startTime := time.Now()
// TODO: Skip the first 'latency' samples for the stream.
fmt.Printf("TODO: Skip latency (= %d) samples)\n", latency)
columns := constantQ.ProcessChannel(inputSound.GetSamples())
columns2 := constantQ2.ProcessChannel(inputSound2.GetSamples())
samples := cqInverse.ProcessChannel(mergeChannels(columns, columns2))
asSound := s.WrapChannelAsSound(samples)
// if outputFile != "" {
// f.Write(asSound, outputFile)
// } else {
output.Play(asSound)
// }
elapsedSeconds := time.Since(startTime).Seconds()
fmt.Printf("elapsed time (not counting init): %f sec\n", elapsedSeconds)
}
func main() {
version := flag.Bool("version", false, "print version number")
debug := flag.Bool("debug", false, "debug on")
hardlinks := flag.Bool("hardlinks", false, "support hardlinks")
delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.")
branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.")
deldirname := flag.String(
"deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.")
flag.Parse()
if *version {
fmt.Println(fuse.Version())
os.Exit(0)
}
if len(flag.Args()) < 2 {
fmt.Println("Usage:\n main MOUNTPOINT BASEDIR")
os.Exit(2)
}
ufsOptions := unionfs.UnionFsOptions{
DeletionCacheTTL: time.Duration(*delcache_ttl * float64(time.Second)),
BranchCacheTTL: time.Duration(*branchcache_ttl * float64(time.Second)),
DeletionDirName: *deldirname,
}
options := unionfs.AutoUnionFsOptions{
UnionFsOptions: ufsOptions,
FileSystemOptions: fuse.FileSystemOptions{
EntryTimeout: time.Second,
AttrTimeout: time.Second,
NegativeTimeout: time.Second,
Owner: fuse.CurrentOwner(),
},
UpdateOnMount: true,
PathNodeFsOptions: fuse.PathNodeFsOptions{
ClientInodes: *hardlinks,
},
}
fmt.Printf("AutoUnionFs - Go-FUSE Version %v.\n", fuse.Version())
gofs := unionfs.NewAutoUnionFs(flag.Arg(1), options)
pathfs := fuse.NewPathNodeFs(gofs, nil)
state, conn, err := fuse.MountNodeFileSystem(flag.Arg(0), pathfs, nil)
if err != nil {
fmt.Printf("Mount fail: %v\n", err)
os.Exit(1)
}
pathfs.Debug = *debug
conn.Debug = *debug
state.Debug = *debug
gofs.SetMountState(state)
state.Loop()
}
func ReadInputInfo() *ivc.ParaInfo {
var genome_file = flag.String("R", "", "reference genome file")
var var_prof_file = flag.String("V", "", "variant profile file")
var idx_dir = flag.String("I", "", "index directory")
var read_file_1 = flag.String("1", "", "pairend read file, first end")
var read_file_2 = flag.String("2", "", "pairend read file, second end")
var var_call_file = flag.String("O", "", "variant call output file")
var search_mode = flag.Int("mode", 0, "searching mode for finding seeds (1: random (default), 2: deterministic)")
var start_pos = flag.Int("start", 0, "starting position on reads for finding seeds")
var search_step = flag.Int("step", 0, "step for searching in deterministic mode")
var max_snum = flag.Int("maxs", 0, "maximum number of seeds")
var max_psnum = flag.Int("maxp", 0, "maximum number of paired-seeds")
var min_slen = flag.Int("lmin", 0, "minimum length of seeds")
var max_slen = flag.Int("lmax", 0, "maximum length of seeds")
var dist_thres = flag.Float64("d", 0, "threshold of alignment distances")
var iter_num = flag.Int("r", 0, "maximum number of iterations")
var sub_cost = flag.Float64("s", 0, "substitution cost")
var gap_open = flag.Float64("o", 0, "gap open cost")
var gap_ext = flag.Float64("e", 0, "gap extension cost")
var proc_num = flag.Int("t", 0, "maximum number of CPUs")
var debug_mode = flag.Bool("debug", false, "turn on debug mode.")
flag.Parse()
_, genome_file_name := path.Split(*genome_file)
multi_seq_file_name := path.Join(*idx_dir, genome_file_name) + ".mgf"
rev_multi_seq_file_name := path.Join(*idx_dir, genome_file_name) + ".rev.mgf"
_, var_prof_file_name := path.Split(*var_prof_file)
var_prof_index_file_name := path.Join(*idx_dir, var_prof_file_name) + ".idx"
para_info := new(ivc.ParaInfo)
para_info.Ref_file = multi_seq_file_name
para_info.Var_prof_file = var_prof_index_file_name
para_info.Index_file = multi_seq_file_name + ".index/"
para_info.Rev_index_file = rev_multi_seq_file_name + ".index/"
para_info.Read_file_1 = *read_file_1
para_info.Read_file_2 = *read_file_2
para_info.Var_call_file = *var_call_file
para_info.Search_mode = *search_mode
para_info.Start_pos = *start_pos
para_info.Search_step = *search_step
para_info.Max_snum = *max_snum
para_info.Max_psnum = *max_psnum
para_info.Min_slen = *min_slen
para_info.Max_slen = *max_slen
para_info.Dist_thres = *dist_thres
para_info.Iter_num = *iter_num
para_info.Sub_cost = *sub_cost
para_info.Gap_open = *gap_open
para_info.Gap_ext = *gap_ext
para_info.Proc_num = *proc_num
para_info.Debug_mode = *debug_mode
return para_info
}
func main() {
var (
width = flag.Int("w", 1024, "width")
top = flag.Int("top", 50, "top")
left = flag.Int("left", 100, "left margin")
vp = flag.Int("vp", 512, "visualization point")
vw = flag.Int("vw", 300, "visual area width")
bh = flag.Int("bh", 20, "bar height")
smax = flag.Float64("sm", 10, "maximum speedup")
dmax = flag.Float64("dm", 100, "maximum delta")
title = flag.String("title", "", "title")
speedcolor = flag.String("scolor", "green", "speedup color")
regresscolor = flag.String("rcolor", "red", "regression color")
style = flag.String("style", "bar", "set the style (bar or inline)")
lines = flag.Bool("line", false, "show lines between entries")
coldata = flag.Bool("col", false, "show data in a single column")
coltitle = flag.Bool("coltitle", true, "show title for columns")
)
flag.Parse()
g := geometry{
width: *width,
top: *top,
left: *left,
vp: *vp,
vwidth: *vw,
barHeight: *bh,
title: *title,
scolor: *speedcolor,
rcolor: *regresscolor,
style: *style,
dolines: *lines,
coldata: *coldata,
speedupmax: *smax,
deltamax: *dmax,
coltitle: *coltitle,
coltitle_not_print: true,
}
var svg_buffer bytes.Buffer
canvas_b := svg.New(&svg_buffer)
var _height int
if len(flag.Args()) > 0 {
for _, f := range flag.Args() {
_height = process(canvas_b, f, g)
}
} else {
_height = process(canvas_b, "", g)
}
canvas := svg.New(os.Stdout)
canvas.Start(g.width, _height)
svg_buffer.WriteTo(os.Stdout)
canvas.End()
}
func init() {
runtime.GOMAXPROCS(runtime.NumCPU())
rand.Seed(int64(time.Now().Nanosecond()))
path = flag.String("path", "./brot.png", "Output filename")
center_x = flag.Float64("x", -.5, "X center on mandelbrot plane")
center_y = flag.Float64("y", 0, "Y center on mandelbrot plane")
zoom = flag.Float64("zoom", 1, "Zoom Multiplier")
width = flag.Int("width", 500, "Width of final image")
height = flag.Int("height", 500, "Height of final iage")
iter = flag.Int("iter", 150, "Escape analysis iterations")
limit = flag.Float64("limit", 1000, "Limit for escape analysis")
interesting = flag.Bool("interesting", false, "Use preselected interesting parameters")
}
func main() {
version := flag.Bool("version", false, "print version number")
debug := flag.Bool("debug", false, "debug on")
threaded := flag.Bool("threaded", true, "threading on")
delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.")
branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.")
deldirname := flag.String(
"deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.")
flag.Parse()
if *version {
fmt.Println(fuse.Version())
os.Exit(0)
}
if len(flag.Args()) < 2 {
fmt.Println("Usage:\n main MOUNTPOINT BASEDIR")
os.Exit(2)
}
ufsOptions := unionfs.UnionFsOptions{
DeletionCacheTTLSecs: *delcache_ttl,
BranchCacheTTLSecs: *branchcache_ttl,
DeletionDirName: *deldirname,
}
options := unionfs.AutoUnionFsOptions{
UnionFsOptions: ufsOptions,
FileSystemOptions: fuse.FileSystemOptions{
EntryTimeout: 1.0,
AttrTimeout: 1.0,
NegativeTimeout: 1.0,
Owner: fuse.CurrentOwner(),
},
UpdateOnMount: true,
}
gofs := unionfs.NewAutoUnionFs(flag.Arg(1), options)
pathfs := fuse.NewPathNodeFs(gofs)
state, conn, err := fuse.MountNodeFileSystem(flag.Arg(0), pathfs, nil)
if err != nil {
fmt.Printf("Mount fail: %v\n", err)
os.Exit(1)
}
pathfs.Debug = *debug
conn.Debug = *debug
state.Debug = *debug
state.Loop(*threaded)
}
func TestParse_GlobalAndCustomOverwrite(t *testing.T) {
resetForTesting("-a=true", "-b=5", "-c=Hello")
flagA := flag.Bool("a", false, "")
flagB := flag.Float64("b", 0.0, "")
flagC := flag.String("c", "", "")
name := "custom"
custom := flag.NewFlagSet(name, flag.ExitOnError)
flagD := custom.String("d", "", "")
Register(name, custom)
parse(t, "./testdata/globalandcustom.ini", "")
if !*flagA {
t.Errorf("flagA found %v, expected true", *flagA)
}
if *flagB != 5.0 {
t.Errorf("flagB found %v, expected 5.0", *flagB)
}
if *flagC != "Hello" {
t.Errorf("flagC found %v, expected 'Hello'", *flagC)
}
if *flagD != "Hello d" {
t.Errorf("flagD found %v, expected 'Hello d'", *flagD)
}
}
func main() {
numCPU := runtime.NumCPU()
runtime.GOMAXPROCS(numCPU)
obliteration := flag.Int("concurrency", 10, "threads and connections to use for load generation")
host := flag.String("zk", "master.mesos:2181", "host:port for zk")
size := flag.Int("size", 1024, "bytes per key written")
ratio := flag.Float64("ratio", 0.2, "0 to 1 ratio of reads to writes. 0 is all writes, 1 is all reads.")
flag.Parse()
value := gen(*size)
conns := []*zk.Conn{}
for i := 0; i < *obliteration; i++ {
cli, _, err := zk.Connect([]string{*host}, 5*time.Second)
if err != nil {
fmt.Printf("error connecting to zk: %v\n", err)
os.Exit(1)
}
conns = append(conns, cli)
}
doRpc := func() {
cli := conns[rand.Intn(len(conns))]
bench(cli, value, *ratio)
}
loghisto.PrintBenchmark("benchmark1234", uint(*obliteration), doRpc)
}
func main() {
title := flag.String("title", "", "영화 이름") // 명령줄 옵션을 받은 뒤 문자열로 저장
runtime := flag.Int("runtime", 0, "상영 시간") // 명령줄 옵션을 받은 뒤 정수로 저장
rating := flag.Float64("rating", 0.0, "평점") // 명령줄 옵션을 받은 뒤 실수로 저장
release := flag.Bool("release", false, "개봉 여부") // 명령줄 옵션을 받은 뒤 불로 저장
flag.Parse() // 명령줄 옵션의 내용을 각 자료형별로 분석
if flag.NFlag() == 0 { // 명령줄 옵션의 개수가 0개이면
flag.Usage() // 명령줄 옵션 기본 사용법 출력
return
}
fmt.Printf(
"영화 이름: %s\n상영 시간: %d분\n평점: %f\n",
*title, // 포인터이므로 값을 꺼낼 때는 역참조 사용
*runtime,
*rating,
) // 명령줄 옵션으로 받은 값을 출력
if *release == true {
fmt.Println("개봉 여부: 개봉")
} else {
fmt.Println("개봉 여부: 미개봉")
}
}
func main() {
var (
port = flag.String("port", "8080", "Port to bind HTTP listener")
declineAmount = flag.Float64("decline", 100, "Decline payments over certain amount")
)
flag.Parse()
// Mechanical stuff.
errc := make(chan error)
ctx := context.Background()
handler, logger := payment.WireUp(ctx, float32(*declineAmount))
// Create and launch the HTTP server.
go func() {
logger.Log("transport", "HTTP", "port", *port)
errc <- http.ListenAndServe(":"+*port, handler)
}()
// Capture interrupts.
go func() {
c := make(chan os.Signal)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
errc <- fmt.Errorf("%s", <-c)
}()
logger.Log("exit", <-errc)
}
