func (opts *Options) GetF(name string) float64 {
	optName := parseName(name)
	opt, ok := opts.full[optName.Long]
	switch {
	case !ok:
		return 0.0
	case opts.full[optName.Long].Value == nil:
		return 0.0
	case opt.Type == STRING, opt.Type == MIXED:
		result, err := strconv.ParseFloat(opt.Value.(string), 64)
		if err == nil {
			return result
		}
		return 0.0
	case opt.Type == INT:
		return float64(opt.Value.(int))
	case opt.Type == BOOL:
		if opt.Value.(bool) {
			return 1.0
		}
		return 0.0
	default:
		return opt.Value.(float64)
	}
}
GetF returns option value as floating number
package options
import (
	"fmt"
	"os"
	"strconv"
	"strings"
)
const (
	STRING = iota  
	INT            
	BOOL           
	FLOAT          
	MIXED          
)
const (
	ERROR_UNSUPPORTED = iota
	ERROR_NO_NAME
	ERROR_DUPLICATE_LONGNAME
	ERROR_DUPLICATE_SHORTNAME
	ERROR_OPTION_IS_NIL
	ERROR_EMPTY_VALUE
	ERROR_REQUIRED_NOT_SET
	ERROR_WRONG_FORMAT
	ERROR_CONFLICT
	ERROR_BOUND_NOT_SET
	ERROR_UNSUPPORTED_VALUE
)
type V struct {
	Type      int      
	Max       float64  
	Min       float64  
	Alias     string   
	Conflicts string   
	Bound     string   
	Mergeble  bool     
	Required  bool     
	set bool  
	Value interface{}  
}
type Map map[string]*V
type Options struct {
	short       map[string]string
	initialized bool
	full        Map
}
type OptionError struct {
	Option      string
	BoundOption string
	Type        int
}
type optionName struct {
	Long  string
	Short string
}
var global *Options
func (opts *Options) Add(name string, option *V) error {
	if !opts.initialized {
		initOptions(opts)
	}
	optName := parseName(name)
	switch {
	case option == nil:
		return OptionError{"--" + optName.Long, "", ERROR_OPTION_IS_NIL}
	case optName.Long == "":
		return OptionError{"", "", ERROR_NO_NAME}
	case opts.full[optName.Long] != nil:
		return OptionError{"--" + optName.Long, "", ERROR_DUPLICATE_LONGNAME}
	case optName.Short != "" && opts.short[optName.Short] != "":
		return OptionError{"-" + optName.Short, "", ERROR_DUPLICATE_SHORTNAME}
	}
	opts.full[optName.Long] = option
	if optName.Short != "" {
		opts.short[optName.Short] = optName.Long
	}
	if option.Alias != "" {
		aliases := parseOptionsList(option.Alias)
		for _, l := range aliases {
			opts.full[l.Long] = option
			if l.Short != "" {
				opts.short[l.Short] = optName.Long
			}
		}
	}
	return nil
}
func (opts *Options) AddMap(optMap Map) []error {
	var errs []error
	for name, opt := range optMap {
		err := opts.Add(name, opt)
		if err != nil {
			errs = append(errs, err)
		}
	}
	return errs
}
func (opts *Options) GetS(name string) string {
	optName := parseName(name)
	opt, ok := opts.full[optName.Long]
	switch {
	case !ok:
		return ""
	case opts.full[optName.Long].Value == nil:
		return ""
	case opt.Type == INT:
		return strconv.Itoa(opt.Value.(int))
	case opt.Type == FLOAT:
		return strconv.FormatFloat(opt.Value.(float64), 'f', -1, 64)
	case opt.Type == BOOL:
		return strconv.FormatBool(opt.Value.(bool))
	default:
		return opt.Value.(string)
	}
}
func (opts *Options) GetI(name string) int {
	optName := parseName(name)
	opt, ok := opts.full[optName.Long]
	switch {
	case !ok:
		return 0
	case opts.full[optName.Long].Value == nil:
		return 0
	case opt.Type == STRING, opt.Type == MIXED:
		result, err := strconv.Atoi(opt.Value.(string))
		if err == nil {
			return result
		}
		return 0
	case opt.Type == FLOAT:
		return int(opt.Value.(float64))
	case opt.Type == BOOL:
		if opt.Value.(bool) {
			return 1
		}
		return 0
	default:
		return opt.Value.(int)
	}
}
func (opts *Options) GetB(name string) bool {
	optName := parseName(name)
	opt, ok := opts.full[optName.Long]
	switch {
	case !ok:
		return false
	case opts.full[optName.Long].Value == nil:
		return false
	case opt.Type == STRING, opt.Type == MIXED:
		if opt.Value.(string) == "" {
			return false
		}
		return true
	case opt.Type == FLOAT:
		if opt.Value.(float64) > 0 {
			return true
		}
		return false
	case opt.Type == INT:
		if opt.Value.(int) > 0 {
			return true
		}
		return false
	default:
		return opt.Value.(bool)
	}
}