:param volume: one of [low, medium, high]
353637
def set_siren_volume(self, volume):
        
        values = {
            "desired_state": {
                "siren_volume": volume
            }
        }
        response = self.api_interface.set_device_state(self, values)
        self._update_state_from_response(response)
664695
def scale_to_vol(self, vol):
        """"""

        f = (vol / self.vol_ball) ** (1.0 / self.n)  # linear factor
        self.expand *= f
        self.radius *= f
        self.vol_ball = vol
1292932
def set_m_vol(self, vol=None, relative=False):
        '''
        
        '''
        if vol != None:
            if relative:
                vol += self.m_vol
            self.m_vol = min(max(vol, 0), 1)
        pygame.mixer.music.set_volume(self.m_vol)
935083
def volume_oscillator(volume, short_period, long_period):
    
    catch_errors.check_for_period_error(volume, short_period)
    catch_errors.check_for_period_error(volume, long_period)

    vo = (100 * ((sma(volume, short_period) - sma(volume, long_period)) /
          sma(volume, long_period)))
    return vo
482167
def number_of_volumes(self):
    """"""
    if not self._is_parsed:
      self._Parse()
      self._is_parsed = True

    return len(self._volumes)
1027963
def _func(self, volume, params):
        
        e0, b0, b1, v0 = tuple(params)
        eta = (volume / v0) ** (1. / 3.)
        squiggle = -3.*np.log(eta)
        return e0 + b0 * v0 * squiggle ** 2 / 6. * (3. + squiggle * (b1 - 2))
1096330
def scale_to_vol(self, vol):
        """"""

        f = (vol / self.vol_cube) ** (1.0 / self.n)  # linear factor
        self.expand *= f
        self.hside *= f
        self.vol_cube = vol
772156
def volume_up(self, delta=0.1):
        
        if delta <= 0:
            raise ValueError(
                "volume delta must be greater than zero, not {}".format(delta))
        return self.set_volume(self.status.volume_level + delta)
1044562
def _format_index(self, volume_system, idx):
        """"""

        if volume_system.parent.index is not None:
            return '{0}.{1}'.format(volume_system.parent.index, idx)
        else:
            return str(idx)
44144
async def volume(self, ctx, volume: int):
        """"""

        if ctx.voice_client is None:
            return await ctx.send("Not connected to a voice channel.")

        ctx.voice_client.source.volume = volume / 100
        await ctx.send("Changed volume to {}%".format(volume))
912996
def get(self, volume_ids=None, filters=None):
        """"""
        params = {}
        if filters:
            params["filters"] = make_filters(filters)
        if isinstance(volume_ids, str):
            volume_ids = [volume_ids]
        return self.call("DescribeVolumes",
                         VolumeIds=volume_ids,
                         response_data_key="Volumes",
                         **params)
1230113
def volumes(self):
    """"""
    if not self._is_parsed:
      self._Parse()
      self._is_parsed = True

    return iter(self._volumes.values())
535736
def _func(self, volume, params):
        
        e0, b0, b1, v0 = tuple(params)
        return (e0
                + 9.0 / 8.0 * b0 * v0 * ((v0 / volume)**(2.0/3.0) - 1.0) ** 2
                + 9.0 / 16.0 * b0 * v0 * (b1 - 4.) *
                ((v0 / volume)**(2.0/3.0) - 1.0) ** 3)
115907
def set_volume(self, volume):
        """"""
        req_url = ENDPOINTS["setVolume"].format(self.ip_address, self.zone_id)
        params = {"volume": int(volume)}
        return request(req_url, params=params)
638577
def volume(self):
        
        volume = float(np.product(self.primitive.extents))
        return volume
49575
def volume(self) -> float:
        
        m = self._matrix
        return float(abs(dot(np.cross(m[0], m[1]), m[2])))
903299
def on_balance_volume(close_data, volume):
    
    catch_errors.check_for_input_len_diff(close_data, volume)
    obv = np.zeros(len(volume))
    obv[0] = 1
    for idx in range(1, len(obv)):
        if close_data[idx] > close_data[idx-1]:
            obv[idx] = obv[idx-1] + volume[idx]
        elif close_data[idx] < close_data[idx-1]:
            obv[idx] = obv[idx-1] - volume[idx]
        elif close_data[idx] == close_data[idx-1]:
            obv[idx] = obv[idx-1]
    return obv