'''simple docstring'''




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
  from transformers import SpeechaTextFeatureExtractor

__UpperCAmelCase					=random.Random()






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__=1.0							,    UpperCamelCase__=None							,    UpperCamelCase__=None							)      ->       Any:
    if rng is None:
        __lowerCamelCase            =    global_rng

    __lowerCamelCase            =    []
    for batch_idx in range(shape[0]							):
        values.append([]							)
        for _ in range(shape[1]							):
            values[-1].append(rng.random() * scale							)

    return values




@require_torch
@require_torchaudio
class        a__ (  unittest.TestCase					):






     def __init__(					self						:						Tuple    ,							a						:						Dict    ,							a						:						Optional[int]=7    ,							a						:						List[Any]=4_00    ,							a						:						Dict=20_00    ,							a						:						Any=24    ,							a						:						Union[str, Any]=24    ,							a						:						Dict=0.0    ,							a						:						Optional[int]=1_60_00    ,							a						:						Optional[Any]=True    ,							a						:						Any=True    ,							):





         """simple docstring"""



         __lowerCamelCase            =    parent
         __lowerCamelCase            =    batch_size
         __lowerCamelCase            =    min_seq_length
         __lowerCamelCase            =    max_seq_length
         __lowerCamelCase            =    (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         __lowerCamelCase            =    feature_size
         __lowerCamelCase            =    num_mel_bins
         __lowerCamelCase            =    padding_value
         __lowerCamelCase            =    sampling_rate
         __lowerCamelCase            =    return_attention_mask
         __lowerCamelCase            =    do_normalize






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         return {
             "feature_size": self.feature_size,
             "num_mel_bins": self.num_mel_bins,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "return_attention_mask": self.return_attention_mask,
             "do_normalize": self.do_normalize,
         }






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						Optional[int]=False    ,							a						:						Union[str, Any]=False       ):





         """simple docstring"""



         def _flatten(a						:						List[Any]       ):
             return list(itertools.chain(*a       )       )

         if equal_length:
             __lowerCamelCase            =    [floats_list((self.max_seq_length, self.feature_size)       ) for _ in range(self.batch_size       )]
         else:
             # make sure that inputs increase in size
             __lowerCamelCase            =    [
                 floats_list((x, self.feature_size)       )
                 for x in range(self.min_seq_length    ,							self.max_seq_length    ,							self.seq_length_diff       )
             ]
         if numpify:
             __lowerCamelCase            =    [np.asarray(a       ) for x in speech_inputs]
         return speech_inputs




@require_torch
@require_torchaudio
class        a__ (  UpperCAmelCase__				,  unittest.TestCase					):
     lowerCamelCase    :	Optional[int]				=SpeechaTextFeatureExtractor if is_speech_available() else None






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



         __lowerCamelCase            =    SpeechaTextFeatureExtractionTester(self       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[str]    ,							a						:						Union[str, Any]       ):





         """simple docstring"""



         self.assertTrue(np.all(np.mean(a    ,							axis=0       ) < 1e-3       )       )
         self.assertTrue(np.all(np.abs(np.var(a    ,							axis=0       ) - 1       ) < 1e-3       )       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         # create three inputs of length 800, 1000, and 1200
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]
         __lowerCamelCase            =    [np.asarray(a       ) for speech_input in speech_inputs]

         # Test feature size
         __lowerCamelCase            =    feature_extractor(a    ,							padding=a    ,							return_tensors='''np'''       ).input_features
         self.assertTrue(input_features.ndim == 3       )
         self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size       )

         # Test not batched input
         __lowerCamelCase            =    feature_extractor(speech_inputs[0]    ,							return_tensors='''np'''       ).input_features
         __lowerCamelCase            =    feature_extractor(np_speech_inputs[0]    ,							return_tensors='''np'''       ).input_features
         self.assertTrue(np.allclose(a    ,							a    ,							atol=1e-3       )       )

         # Test batched
         __lowerCamelCase            =    feature_extractor(a    ,							return_tensors='''np'''       ).input_features
         __lowerCamelCase            =    feature_extractor(a    ,							return_tensors='''np'''       ).input_features
         for enc_seq_a, enc_seq_a in zip(a    ,							a       ):
             self.assertTrue(np.allclose(a    ,							a    ,							atol=1e-3       )       )

         # Test 2-D numpy arrays are batched.
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in (8_00, 8_00, 8_00)]
         __lowerCamelCase            =    np.asarray(a       )
         __lowerCamelCase            =    feature_extractor(a    ,							return_tensors='''np'''       ).input_features
         __lowerCamelCase            =    feature_extractor(a    ,							return_tensors='''np'''       ).input_features
         for enc_seq_a, enc_seq_a in zip(a    ,							a       ):
             self.assertTrue(np.allclose(a    ,							a    ,							atol=1e-3       )       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]

         __lowerCamelCase            =    ['''longest''', '''max_length''', '''do_not_pad''']
         __lowerCamelCase            =    [None, 16, None]
         for max_length, padding in zip(a    ,							a       ):
             __lowerCamelCase            =    feature_extractor(
                 a    ,							padding=a    ,							max_length=a    ,							return_attention_mask=a       )
             __lowerCamelCase            =    inputs.input_features
             __lowerCamelCase            =    inputs.attention_mask
             __lowerCamelCase            =    [np.sum(a       ) for x in attention_mask]

             self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
             self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
             self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]

         __lowerCamelCase            =    ['''longest''', '''max_length''', '''do_not_pad''']
         __lowerCamelCase            =    [None, 16, None]
         for max_length, padding in zip(a    ,							a       ):
             __lowerCamelCase            =    feature_extractor(
                 a    ,							max_length=a    ,							padding=a    ,							return_tensors='''np'''    ,							return_attention_mask=a       )
             __lowerCamelCase            =    inputs.input_features
             __lowerCamelCase            =    inputs.attention_mask
             __lowerCamelCase            =    [np.sum(a       ) for x in attention_mask]

             self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
             self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6       )
             self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
             self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6       )
             self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]
         __lowerCamelCase            =    feature_extractor(
             a    ,							padding='''max_length'''    ,							max_length=4    ,							truncation=a    ,							return_tensors='''np'''    ,							return_attention_mask=a    ,							)
         __lowerCamelCase            =    inputs.input_features
         __lowerCamelCase            =    inputs.attention_mask
         __lowerCamelCase            =    np.sum(attention_mask == 1    ,							axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1]       )
         self._check_zero_mean_unit_variance(input_features[2]       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]
         __lowerCamelCase            =    feature_extractor(
             a    ,							padding='''longest'''    ,							max_length=4    ,							truncation=a    ,							return_tensors='''np'''    ,							return_attention_mask=a    ,							)
         __lowerCamelCase            =    inputs.input_features
         __lowerCamelCase            =    inputs.attention_mask
         __lowerCamelCase            =    np.sum(attention_mask == 1    ,							axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape    ,							(3, 4, 24)       )

         __lowerCamelCase            =    [floats_list((1, x)       )[0] for x in range(8_00    ,							14_00    ,							2_00       )]
         __lowerCamelCase            =    feature_extractor(
             a    ,							padding='''longest'''    ,							max_length=16    ,							truncation=a    ,							return_tensors='''np'''    ,							return_attention_mask=a    ,							)
         __lowerCamelCase            =    inputs.input_features
         __lowerCamelCase            =    inputs.attention_mask
         __lowerCamelCase            =    np.sum(attention_mask == 1    ,							axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape    ,							(3, 6, 24)       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         import torch

         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    np.random.rand(1_00    ,							32       ).astype(np.floataa       )
         __lowerCamelCase            =    np_speech_inputs.tolist()

         for inputs in [py_speech_inputs, np_speech_inputs]:
             __lowerCamelCase            =    feature_extractor.pad([{'''input_features''': inputs}]    ,							return_tensors='''np'''       )
             self.assertTrue(np_processed.input_features.dtype == np.floataa       )
             __lowerCamelCase            =    feature_extractor.pad([{'''input_features''': inputs}]    ,							return_tensors='''pt'''       )
             self.assertTrue(pt_processed.input_features.dtype == torch.floataa       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]    ,							a						:						List[str]       ):





         """simple docstring"""



         from datasets import load_dataset

         __lowerCamelCase            =    load_dataset('''hf-internal-testing/librispeech_asr_dummy'''    ,							'''clean'''    ,							split='''validation'''       )
         # automatic decoding with librispeech
         __lowerCamelCase            =    ds.sort('''id'''       ).select(range(a       )       )[:num_samples]['''audio''']

         return [x["array"] for x in speech_samples]






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



         __lowerCamelCase            =    np.array([
             -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
             -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
             -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
         ]       )
         # fmt: on

         __lowerCamelCase            =    self._load_datasamples(1       )
         __lowerCamelCase            =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         __lowerCamelCase            =    feature_extractor(a    ,							return_tensors='''pt'''       ).input_features
         self.assertEquals(input_features.shape    ,							(1, 5_84, 24)       )
         self.assertTrue(np.allclose(input_features[0, 0, :30]    ,							a    ,							atol=1e-4       )       )

'''simple docstring'''




import numpy as np






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							)      ->       str:
    __lowerCamelCase            =    int(np.ceil((x_end - xa) / h							)							)
    __lowerCamelCase            =    np.zeros((n + 1,)							)
    __lowerCamelCase            =    ya
    __lowerCamelCase            =    xa

    for k in range(UpperCamelCase__							):
        __lowerCamelCase            =    f(UpperCamelCase__							,    y[k]							)
        __lowerCamelCase            =    f(x + 0.5 * h							,    y[k] + 0.5 * h * ka							)
        __lowerCamelCase            =    f(x + 0.5 * h							,    y[k] + 0.5 * h * ka							)
        __lowerCamelCase            =    f(x + h							,    y[k] + h * ka							)
        __lowerCamelCase            =    y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
        x += h

    return y


if __name__ == "__main__":
  import doctest

  doctest.testmod()
