wavify 0.1.0 → 0.2.0

data/lib/wavify/dsp/filter.rb

@@ -5,6 +5,13 @@ module Wavify
   module DSP
     # Stateful biquad filter with common factory constructors.
     class Filter
+      # Minimum tail window used to drain an IIR filter.
+      DEFAULT_TAIL_SECONDS = 0.05
+      # Hard limit on automatic filter tail rendering.
+      MAX_TAIL_SECONDS = 10.0
+      # Amplitude below which an IIR tail is treated as silent.
+      TAIL_AMPLITUDE = 1.0e-6
+
       attr_reader :type, :cutoff, :q, :gain_db
 
       # Builds a low-pass filter.
@@ -21,8 +28,15 @@ module Wavify
         new(:highpass, cutoff: cutoff, q: q)
       end
 
-      def self.bandpass(center:, bandwidth:)
-        raise InvalidParameterError, "bandwidth must be positive" unless bandwidth.is_a?(Numeric) && bandwidth.positive?
+      def self.bandpass(center: nil, bandwidth: nil, cutoff: nil, q: nil)
+        return new(:bandpass, cutoff: cutoff, q: q || 0.707) if cutoff
+
+        unless center.is_a?(Numeric) && center.respond_to?(:finite?) && center.finite? && center.positive?
+          raise InvalidParameterError, "center must be a positive finite Numeric"
+        end
+        unless bandwidth.is_a?(Numeric) && bandwidth.respond_to?(:finite?) && bandwidth.finite? && bandwidth.positive?
+          raise InvalidParameterError, "bandwidth must be a positive finite Numeric"
+        end
 
         new(:bandpass, cutoff: center, q: center.to_f / bandwidth)
       end
@@ -64,13 +78,20 @@ module Wavify
         @coefficients = nil
         @coeff_sample_rate = nil
         @channel_states = []
+        @runtime_channels = nil
       end
 
       def apply(buffer)
+        DSP::Processor.render(self, buffer)
+      end
+
+      # Processes a streaming chunk while preserving filter state.
+      def process(buffer)
         raise InvalidParameterError, "buffer must be Core::SampleBuffer" unless buffer.is_a?(Core::SampleBuffer)
 
         float_format = buffer.format.with(sample_format: :float, bit_depth: 32)
         float_buffer = buffer.convert(float_format)
+        prepare_runtime_format!(sample_rate: float_format.sample_rate, channels: float_format.channels)
         processed = process_interleaved(
           float_buffer.samples,
           sample_rate: float_format.sample_rate,
@@ -81,12 +102,14 @@ module Wavify
       end
 
       def process_sample(sample, sample_rate:, channel: 0)
-        raise InvalidParameterError, "sample must be Numeric" unless sample.is_a?(Numeric)
+        unless sample.is_a?(Numeric) && sample.respond_to?(:finite?) && sample.finite?
+          raise InvalidParameterError, "sample must be a finite Numeric"
+        end
         raise InvalidParameterError, "channel must be a non-negative Integer" unless channel.is_a?(Integer) && channel >= 0
         raise InvalidParameterError, "sample_rate must be a positive Integer" unless sample_rate.is_a?(Integer) && sample_rate.positive?
 
         update_coefficients!(sample_rate)
-        ensure_channel_states!(channel + 1)
+        ensure_sample_channel_state!(channel)
         state = @channel_states[channel]
         x = sample.to_f
         y = compute_biquad(state, x)
@@ -94,15 +117,95 @@ module Wavify
         y
       end
 
+      # Emits the decaying IIR state after the input ends.
+      #
+      # @param format [Core::Format, nil] optional target format
+      # @return [Enumerator<Core::SampleBuffer>, nil]
+      def flush(format: nil)
+        return nil unless @coeff_sample_rate && filter_state_active?
+        if format && !format.is_a?(Core::Format)
+          raise InvalidParameterError, "format must be Core::Format"
+        end
+
+        channels = @channel_states.length
+        runtime_format = Core::Format.new(
+          channels: channels,
+          sample_rate: @coeff_sample_rate,
+          bit_depth: 32,
+          sample_format: :float
+        )
+        remaining = tail_frame_count(@coeff_sample_rate)
+        target_format = format || runtime_format
+        Enumerator.new do |yielder|
+          while remaining.positive?
+            frames = [remaining, DSP::Processor::TAIL_CHUNK_FRAMES].min
+            silence = Array.new(frames * channels, 0.0)
+            processed = process_interleaved(silence, sample_rate: @coeff_sample_rate, channels: channels)
+            yielder << Core::SampleBuffer.new(processed, runtime_format).convert(target_format)
+            remaining -= frames
+          end
+        ensure
+          reset
+        end
+      end
+
+      # Estimated time for the biquad poles to decay below -120 dB.
+      def tail_duration
+        return DEFAULT_TAIL_SECONDS unless @coeff_sample_rate && @coefficients
+
+        tail_frame_count(@coeff_sample_rate).to_f / @coeff_sample_rate
+      end
+
       # Clears internal filter state for all channels.
       #
       # @return [void]
       def reset
+        @coefficients = nil
+        @coeff_sample_rate = nil
         @channel_states = []
+        @runtime_channels = nil
+        self
+      end
+
+      def build_runtime
+        dup.reset
+      end
+
+      def latency
+        0.0
+      end
+
+      def lookahead
+        0.0
       end
 
       private
 
+      def filter_state_active?
+        @channel_states.any? { |state| state.values.any? { |value| !value.zero? } }
+      end
+
+      def tail_frame_count(sample_rate)
+        radius = maximum_pole_radius
+        frames = if radius <= 0.0
+                   2
+                 elsif radius >= 1.0
+                   (MAX_TAIL_SECONDS * sample_rate).ceil
+                 else
+                   (Math.log(TAIL_AMPLITUDE) / Math.log(radius)).ceil
+                 end
+        frames.clamp(2, (MAX_TAIL_SECONDS * sample_rate).ceil)
+      end
+
+      def maximum_pole_radius
+        _b0, _b1, _b2, a1, a2 = @coefficients
+        discriminant = (a1 * a1) - (4.0 * a2)
+        return Math.sqrt(a2.abs) if discriminant.negative?
+
+        root = Math.sqrt(discriminant)
+        [(-a1 + root) / 2.0, (-a1 - root) / 2.0].map(&:abs).max
+      end
+
       def process_interleaved(samples, sample_rate:, channels:)
         update_coefficients!(sample_rate)
         ensure_channel_states!(channels)
@@ -122,17 +225,41 @@ module Wavify
       def update_coefficients!(sample_rate)
         return if @coeff_sample_rate == sample_rate && @coefficients
 
+        if @coeff_sample_rate && @coeff_sample_rate != sample_rate
+          raise InvalidParameterError, "sample rate changed; call reset before processing a new format"
+        end
+
+        validate_cutoff_below_nyquist!(sample_rate)
         @coefficients = coefficients_for(sample_rate)
         @coeff_sample_rate = sample_rate
-        reset
       end
 
       def ensure_channel_states!(channels)
         return if @channel_states.length == channels
 
+        unless @channel_states.empty?
+          raise InvalidParameterError, "channel count changed; call reset before processing a new format"
+        end
+
         @channel_states = Array.new(channels) { { x1: 0.0, x2: 0.0, y1: 0.0, y2: 0.0 } }
       end
 
+      def ensure_sample_channel_state!(channel)
+        until @channel_states.length > channel
+          @channel_states << { x1: 0.0, x2: 0.0, y1: 0.0, y2: 0.0 }
+        end
+      end
+
+      def prepare_runtime_format!(sample_rate:, channels:)
+        if @runtime_channels && @runtime_channels != channels
+          raise InvalidParameterError, "channel count changed; call reset before processing a new format"
+        end
+
+        update_coefficients!(sample_rate)
+        ensure_channel_states!(channels)
+        @runtime_channels = channels
+      end
+
       def compute_biquad(state, x)
         b0, b1, b2, a1, a2 = @coefficients
         (b0 * x) + (b1 * state[:x1]) + (b2 * state[:x2]) - (a1 * state[:y1]) - (a2 * state[:y2])
@@ -250,22 +377,36 @@ module Wavify
       end
 
       def validate_cutoff!(cutoff)
-        raise InvalidParameterError, "cutoff must be a positive Numeric" unless cutoff.is_a?(Numeric) && cutoff.positive?
+        unless cutoff.is_a?(Numeric) && cutoff.respond_to?(:finite?) && cutoff.finite? && cutoff.positive?
+          raise InvalidParameterError, "cutoff must be a positive finite Numeric"
+        end
 
         cutoff.to_f
       end
 
       def validate_q!(q)
-        raise InvalidParameterError, "q must be a positive Numeric" unless q.is_a?(Numeric) && q.positive?
+        unless q.is_a?(Numeric) && q.respond_to?(:finite?) && q.finite? && q.positive?
+          raise InvalidParameterError, "q must be a positive finite Numeric"
+        end
 
         q.to_f
       end
 
       def validate_gain!(gain_db)
-        raise InvalidParameterError, "gain_db must be Numeric" unless gain_db.is_a?(Numeric)
+        unless gain_db.is_a?(Numeric) && gain_db.respond_to?(:finite?) && gain_db.finite?
+          raise InvalidParameterError, "gain_db must be a finite Numeric"
+        end
 
         gain_db.to_f
       end
+
+      def validate_cutoff_below_nyquist!(sample_rate)
+        nyquist = sample_rate / 2.0
+        return if @cutoff < nyquist
+
+        raise InvalidParameterError,
+              "cutoff must be below Nyquist frequency (#{nyquist} Hz) for sample_rate #{sample_rate}"
+      end
     end
   end
 end

data/lib/wavify/dsp/headroom.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Wavify
+  module DSP
+    # Applies only the gain needed to keep each mixed frame within full scale.
+    module Headroom
+      # Default look-behind/look-ahead smoothing window for gain transitions.
+      DEFAULT_SMOOTHING_SECONDS = 0.005
+
+      def self.apply!(samples, channels:, sample_rate:, smoothing_seconds: DEFAULT_SMOOTHING_SECONDS)
+        smoothing = validate_smoothing!(smoothing_seconds)
+        gains = frame_gains(samples, channels: channels, sample_rate: sample_rate, smoothing_seconds: smoothing)
+        samples.each_index do |index|
+          samples[index] = (samples.fetch(index) * gains.fetch(index / channels)).clamp(-1.0, 1.0)
+        end
+        samples
+      end
+
+      def self.frame_gains(samples, channels:, sample_rate:, smoothing_seconds:)
+        gains = samples.each_slice(channels).map do |frame|
+          peak = frame.reduce(0.0) { |maximum, sample| [maximum, sample.abs].max }
+          peak > 1.0 ? 1.0 / peak : 1.0
+        end
+        return gains if gains.length < 2
+
+        smoothing_frames = (sample_rate * smoothing_seconds).round
+        return gains if smoothing_frames < 2
+
+        smooth_gain_transitions(gains, smoothing_frames)
+      end
+      private_class_method :frame_gains
+
+      def self.smooth_gain_transitions(targets, smoothing_frames)
+        gains = targets.dup
+        step = 1.0 / smoothing_frames
+
+        1.upto(gains.length - 1) do |index|
+          gains[index] = [gains.fetch(index), gains.fetch(index - 1) + step].min
+        end
+        (gains.length - 2).downto(0) do |index|
+          gains[index] = [gains.fetch(index), gains.fetch(index + 1) + step].min
+        end
+        gains
+      end
+      private_class_method :smooth_gain_transitions
+
+      def self.validate_smoothing!(value)
+        unless value.is_a?(Numeric) && value.respond_to?(:finite?) && value.finite? && value >= 0.0
+          raise InvalidParameterError, "headroom smoothing must be a non-negative finite Numeric"
+        end
+
+        value.to_f
+      end
+      private_class_method :validate_smoothing!
+    end
+  end
+end

data/lib/wavify/dsp/lfo.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Wavify
+  module DSP
+    # Low frequency oscillator for modulation sources.
+    class LFO
+      WAVEFORMS = %i[sine triangle square sawtooth].freeze
+
+      def initialize(rate:, sample_rate:, waveform: :sine, phase: 0.0)
+        @rate = validate_positive!(rate, :rate)
+        @sample_rate = validate_positive!(sample_rate, :sample_rate)
+        @waveform = validate_waveform!(waveform)
+        @initial_phase = phase.to_f % 1.0
+        reset
+      end
+
+      def next_value
+        value = value_at_phase(@phase)
+        @phase = (@phase + (@rate / @sample_rate)) % 1.0
+        value
+      end
+
+      def value_at(offset = 0.0)
+        value_at_phase((@phase + offset.to_f) % 1.0)
+      end
+
+      def reset
+        @phase = @initial_phase
+        self
+      end
+
+      private
+
+      def value_at_phase(phase)
+        case @waveform
+        when :sine
+          Math.sin(2.0 * Math::PI * phase)
+        when :triangle
+          1.0 - (4.0 * (phase - 0.5).abs)
+        when :square
+          phase < 0.5 ? 1.0 : -1.0
+        when :sawtooth
+          (2.0 * phase) - 1.0
+        end
+      end
+
+      def validate_positive!(value, name)
+        unless value.is_a?(Numeric) && value.respond_to?(:finite?) && value.finite? && value.positive?
+          raise InvalidParameterError, "#{name} must be a positive finite Numeric"
+        end
+
+        value.to_f
+      end
+
+      def validate_waveform!(waveform)
+        value = waveform.to_sym
+        return value if WAVEFORMS.include?(value)
+
+        raise InvalidParameterError, "unsupported LFO waveform: #{waveform.inspect}"
+      rescue NoMethodError
+        raise InvalidParameterError, "waveform must be Symbol/String: #{waveform.inspect}"
+      end
+    end
+  end
+end

data/lib/wavify/dsp/loudness_meter.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Wavify
+  module DSP
+    # ITU-R BS.1770 integrated loudness meter with EBU-style gating.
+    class LoudnessMeter
+      LOUDNESS_OFFSET = -0.691
+      ABSOLUTE_GATE_LUFS = -70.0
+      RELATIVE_GATE_LU = -10.0
+      BLOCK_SECONDS = 0.4
+      STEP_SECONDS = 0.1
+      SHORT_TERM_SECONDS = 3.0
+      TRUE_PEAK_OVERSAMPLING = 4
+      TRUE_PEAK_RADIUS = 8
+
+      class << self
+        # Measures integrated loudness. Inputs shorter than the BS.1770 400 ms
+        # block are treated as a single partial block.
+        def integrated(samples, sample_rate: nil, channels: nil, format: nil, channel_layout: nil)
+          samples, sample_rate, channels, channel_layout = measurement_input(
+            samples,
+            sample_rate: sample_rate,
+            channels: channels,
+            format: format,
+            channel_layout: channel_layout
+          )
+          return -Float::INFINITY if samples.empty?
+
+          weighted = k_weight(samples, sample_rate: sample_rate, channels: channels)
+          energies = block_energies(
+            weighted,
+            sample_rate: sample_rate,
+            channels: channels,
+            channel_layout: channel_layout
+          )
+          absolute_gated = energies.select { |energy| loudness_for_energy(energy) >= ABSOLUTE_GATE_LUFS }
+          return -Float::INFINITY if absolute_gated.empty?
+
+          relative_gate = loudness_for_energy(mean(absolute_gated)) + RELATIVE_GATE_LU
+          relative_gated = absolute_gated.select { |energy| loudness_for_energy(energy) >= relative_gate }
+          loudness_for_energy(mean(relative_gated))
+        end
+
+        # Measures the most recent 400 ms loudness window without gating.
+        def momentary(samples, sample_rate: nil, channels: nil, format: nil, channel_layout: nil)
+          window_loudness(
+            samples,
+            seconds: BLOCK_SECONDS,
+            sample_rate: sample_rate,
+            channels: channels,
+            format: format,
+            channel_layout: channel_layout
+          )
+        end
+
+        # Measures the most recent 3 second loudness window without gating.
+        def short_term(samples, sample_rate: nil, channels: nil, format: nil, channel_layout: nil)
+          window_loudness(
+            samples,
+            seconds: SHORT_TERM_SECONDS,
+            sample_rate: sample_rate,
+            channels: channels,
+            format: format,
+            channel_layout: channel_layout
+          )
+        end
+
+        # Estimates inter-sample true peak with windowed-sinc oversampling.
+        def true_peak(samples, sample_rate: nil, channels: nil, format: nil, oversampling: TRUE_PEAK_OVERSAMPLING)
+          samples, _sample_rate, channels, = measurement_input(
+            samples,
+            sample_rate: sample_rate,
+            channels: channels,
+            format: format,
+            channel_layout: nil
+          )
+          unless [2, 4, 8].include?(oversampling)
+            raise InvalidParameterError, "oversampling must be 2, 4, or 8"
+          end
+          return 0.0 if samples.empty?
+
+          channel_samples = Array.new(channels) { [] }
+          samples.each_with_index { |sample, index| channel_samples.fetch(index % channels) << sample.to_f }
+          channel_samples.map { |values| oversampled_peak(values, oversampling) }.max || 0.0
+        end
+
+        private
+
+        def measurement_input(samples, sample_rate:, channels:, format:, channel_layout:)
+          if samples.is_a?(Core::SampleBuffer)
+            format ||= samples.format
+            float_format = samples.format.with(sample_format: :float, bit_depth: 32)
+            samples = (samples.format == float_format ? samples : samples.convert(float_format)).samples
+          end
+          if format
+            raise InvalidParameterError, "format must be Core::Format" unless format.is_a?(Core::Format)
+
+            sample_rate ||= format.sample_rate
+            channels ||= format.channels
+            channel_layout ||= format.channel_layout
+          end
+          unless samples.is_a?(Array) && samples.all? { |sample| sample.is_a?(Numeric) && sample.respond_to?(:finite?) && sample.finite? }
+            raise InvalidParameterError, "samples must be an Array of finite Numeric values"
+          end
+          unless sample_rate.is_a?(Integer) && sample_rate.positive?
+            raise InvalidParameterError, "sample_rate must be a positive Integer"
+          end
+          unless channels.is_a?(Integer) && channels.positive? && (samples.length % channels).zero?
+            raise InvalidParameterError, "channels must be a positive Integer that divides the sample count"
+          end
+          if channel_layout && (!channel_layout.is_a?(Array) || channel_layout.length != channels)
+            raise InvalidParameterError, "channel_layout must contain one position per channel"
+          end
+
+          [samples, sample_rate, channels, channel_layout]
+        end
+
+        def window_loudness(samples, seconds:, sample_rate:, channels:, format:, channel_layout:)
+          samples, sample_rate, channels, channel_layout = measurement_input(
+            samples,
+            sample_rate: sample_rate,
+            channels: channels,
+            format: format,
+            channel_layout: channel_layout
+          )
+          return -Float::INFINITY if samples.empty?
+
+          frames = [samples.length / channels, (seconds * sample_rate).round].min
+          window = samples.last(frames * channels)
+          weighted = k_weight(window, sample_rate: sample_rate, channels: channels)
+          energy = block_energy(weighted, channels: channels, channel_layout: channel_layout)
+          loudness_for_energy(energy)
+        end
+
+        def k_weight(samples, sample_rate:, channels:)
+          shelf = high_shelf_coefficients(sample_rate)
+          highpass = highpass_coefficients(sample_rate)
+          apply_biquad(apply_biquad(samples, shelf, channels), highpass, channels)
+        end
+
+        def high_shelf_coefficients(sample_rate)
+          frequency = 1_681.974_450_955_533
+          gain_db = 3.999_843_853_973_347
+          q = 0.707_175_236_955_419_6
+          k = Math.tan(Math::PI * frequency / sample_rate)
+          high_gain = 10.0**(gain_db / 20.0)
+          band_gain = high_gain**0.499_666_774_154_541_6
+          a0 = 1.0 + (k / q) + (k * k)
+
+          [
+            (high_gain + (band_gain * k / q) + (k * k)) / a0,
+            2.0 * ((k * k) - high_gain) / a0,
+            (high_gain - (band_gain * k / q) + (k * k)) / a0,
+            2.0 * ((k * k) - 1.0) / a0,
+            (1.0 - (k / q) + (k * k)) / a0
+          ]
+        end
+
+        def highpass_coefficients(sample_rate)
+          frequency = 38.135_470_876_024_44
+          q = 0.500_327_037_323_877_3
+          k = Math.tan(Math::PI * frequency / sample_rate)
+          a0 = 1.0 + (k / q) + (k * k)
+
+          [
+            1.0,
+            -2.0,
+            1.0,
+            2.0 * ((k * k) - 1.0) / a0,
+            (1.0 - (k / q) + (k * k)) / a0
+          ]
+        end
+
+        def apply_biquad(samples, coefficients, channels)
+          b0, b1, b2, a1, a2 = coefficients
+          x1 = Array.new(channels, 0.0)
+          x2 = Array.new(channels, 0.0)
+          y1 = Array.new(channels, 0.0)
+          y2 = Array.new(channels, 0.0)
+          output = Array.new(samples.length)
+          samples.each_with_index do |sample, index|
+            channel = index % channels
+            value = (b0 * sample) + (b1 * x1.fetch(channel)) + (b2 * x2.fetch(channel)) -
+                    (a1 * y1.fetch(channel)) - (a2 * y2.fetch(channel))
+            x2[channel] = x1.fetch(channel)
+            x1[channel] = sample
+            y2[channel] = y1.fetch(channel)
+            y1[channel] = value
+            output[index] = value
+          end
+          output
+        end
+
+        def block_energies(samples, sample_rate:, channels:, channel_layout:)
+          frame_count = samples.length / channels
+          block_frames = [(BLOCK_SECONDS * sample_rate).round, frame_count].min
+          step_frames = [(STEP_SECONDS * sample_rate).round, 1].max
+          starts = frame_count <= block_frames ? [0] : (0..(frame_count - block_frames)).step(step_frames)
+          gains = channel_gains(channels, channel_layout)
+
+          starts.map do |start_frame|
+            channel_squares = Array.new(channels, 0.0)
+            start_index = start_frame * channels
+            end_index = start_index + (block_frames * channels)
+            samples[start_index...end_index].each_with_index do |sample, index|
+              channel_squares[index % channels] += sample * sample
+            end
+            channel_squares.each_with_index.sum do |square_sum, channel|
+              gains.fetch(channel) * square_sum / block_frames
+            end
+          end
+        end
+
+        def block_energy(samples, channels:, channel_layout:)
+          frames = samples.length / channels
+          return 0.0 if frames.zero?
+
+          squares = Array.new(channels, 0.0)
+          samples.each_with_index { |sample, index| squares[index % channels] += sample * sample }
+          gains = channel_gains(channels, channel_layout)
+          squares.each_with_index.sum { |sum, channel| gains.fetch(channel) * sum / frames }
+        end
+
+        def channel_gains(channels, channel_layout)
+          layout = channel_layout || Core::Format::DEFAULT_CHANNEL_LAYOUTS[channels]
+          return Array.new(channels, 1.0) unless layout
+
+          layout.map do |position|
+            case position.to_sym
+            when :low_frequency then 0.0
+            when :back_left, :back_right, :back_center, :side_left, :side_right then 1.41
+            else 1.0
+            end
+          end
+        end
+
+        def oversampled_peak(samples, factor)
+          peak = samples.map(&:abs).max || 0.0
+          return peak if samples.length < 2
+
+          (0...(samples.length - 1)).each do |index|
+            1.upto(factor - 1) do |step|
+              time = index + (step.to_f / factor)
+              peak = [peak, sinc_interpolate(samples, time).abs].max
+            end
+          end
+          peak
+        end
+
+        def sinc_interpolate(samples, time)
+          center = time.floor
+          start_index = [center - TRUE_PEAK_RADIUS + 1, 0].max
+          end_index = [center + TRUE_PEAK_RADIUS, samples.length - 1].min
+          weighted_sum = 0.0
+          weight_sum = 0.0
+          start_index.upto(end_index) do |index|
+            distance = time - index
+            next if distance.abs >= TRUE_PEAK_RADIUS
+
+            sinc = distance.zero? ? 1.0 : Math.sin(Math::PI * distance) / (Math::PI * distance)
+            window = 0.5 * (1.0 + Math.cos(Math::PI * distance / TRUE_PEAK_RADIUS))
+            weight = sinc * window
+            weighted_sum += samples.fetch(index) * weight
+            weight_sum += weight
+          end
+          weight_sum.zero? ? 0.0 : weighted_sum / weight_sum
+        end
+
+        def loudness_for_energy(energy)
+          return -Float::INFINITY unless energy.positive?
+
+          LOUDNESS_OFFSET + (10.0 * Math.log10(energy))
+        end
+
+        def mean(values)
+          values.sum / values.length.to_f
+        end
+      end
+    end
+  end
+end