//SetGamma generates a 256-element gamma ramp from the specified exponent and then calls
//SetGamma with it.
324645
func (m *Monitor) SetGamma(gamma float32) {
	C.glfwSetGamma(m.data, C.float(gamma))
}
1227894
func (s *TrustedSigners) SetQuantity(v int64) *TrustedSigners {
	s.Quantity = &v
	return s
}
632871
func (s *H264Settings) SetLevel(v string) *H264Settings {
	s.Level = &v
	return s
}
458716
func (l *Limiter) SetMax(max float64) *Limiter {
	l.Lock()
	l.max = max
	l.Unlock()

	return l
}
1071164
func (s *Action) SetLambda(v *LambdaAction) *Action {
	s.Lambda = v
	return s
}
747625
func (g *Generator) SetLinuxResourcesMemoryLimit(limit int64) {
	g.initConfigLinuxResourcesMemory()
	g.Config.Linux.Resources.Memory.Limit = &limit
}
849238
func (vs *Set) SetPower(id crypto.PublicKey, power *big.Int) error {
	vs.ChangePower(id, power)
	return nil
}
1248408
func (light *Light) SetBrightness(percent int) error {
	if percent > 0 && percent <= 100 {
		brightness := uint8(float32(percent) * 2.54) // 100=254x --> 2.54
		lightState := LightState{On: true, Bri: brightness}
		err := light.SetState(lightState)
		if err != nil {
			return err
		}
		return nil
	}
	return errors.New("Light.SetBrightness percentage is not between 1 and 100. ")
}
757156
func (lru *LRUCache) SetCapacity(capacity int64) {
	lru.mu.Lock()
	defer lru.mu.Unlock()

	lru.capacity = capacity
	lru.checkCapacity()
}
377627
func (s *OriginSslProtocols) SetQuantity(v int64) *OriginSslProtocols {
	s.Quantity = &v
	return s
}
377696
func (e *GT) Set(a *GT) *GT {
	if e.p == nil {
		e.p = &gfP12{}
	}
	e.p.Set(a.p)
	return e
}
253
func (s *GeoRestriction) SetQuantity(v int64) *GeoRestriction {
	s.Quantity = &v
	return s
}
849056
func SetLevel(level Level) {
	l, err := parseLevel(level)
	if err != nil {
		fmt.Printf("%v", err)
	}

	std.mu.Lock()
	defer std.mu.Unlock()
	std.Level = l
}
458224
func (s *OriginGroupMembers) SetQuantity(v int64) *OriginGroupMembers {
	s.Quantity = &v
	return s
}
478193
func (p *ProgressBar) Set64(num int64) error {
	p.lock.Lock()
	defer p.lock.Unlock()

	if p.config.max == 0 {
		return errors.New("max must be greater than 0")
	}
	p.state.currentNum = num
	percent := float64(p.state.currentNum) / float64(p.config.max)
	p.state.currentSaucerSize = int(percent * float64(p.config.width))
	p.state.currentPercent = int(percent * 100)
	updateBar := p.state.currentPercent != p.state.lastPercent && p.state.currentPercent > 0

	p.state.currentBytes = float64(percent) * float64(p.config.maxBytes)
	p.state.lastPercent = p.state.currentPercent
	if p.state.currentNum > p.config.max {
		return errors.New("current number exceeds max")
	}

	// always update if show bytes/second or its/second
	if updateBar || p.config.showIterationsPerSecond || p.config.maxBytes > 0 {
		return p.render()
	}

	return nil
}
37083
func (s *Hdr10Metadata) SetMinLuminance(v int64) *Hdr10Metadata {
	s.MinLuminance = &v
	return s
}
1275813
func Lgamma(x float32) (lgamma float32, sign int) {
	return engomath.Lgamma(x)
}