
    bri                     (    d dl Z  G d d          ZdS )    Nc            	           e Zd ZdZdZdZddZ	 	 	 dded	ej	        dz  d
ej
        dz  dej	        fdZ	 	 dded	ej	        dz  d
ej
        dz  dej	        fdZd Zd Zd Zd ZdS )SobolEnginea  
    The :class:`torch.quasirandom.SobolEngine` is an engine for generating
    (scrambled) Sobol sequences. Sobol sequences are an example of low
    discrepancy quasi-random sequences.

    This implementation of an engine for Sobol sequences is capable of
    sampling sequences up to a maximum dimension of 21201. It uses direction
    numbers from https://web.maths.unsw.edu.au/~fkuo/sobol/ obtained using the
    search criterion D(6) up to the dimension 21201. This is the recommended
    choice by the authors.

    References:
      - Art B. Owen. Scrambling Sobol and Niederreiter-Xing points.
        Journal of Complexity, 14(4):466-489, December 1998.

      - I. M. Sobol. The distribution of points in a cube and the accurate
        evaluation of integrals.
        Zh. Vychisl. Mat. i Mat. Phys., 7:784-802, 1967.

    Args:
        dimension (Int): The dimensionality of the sequence to be drawn
        scramble (bool, optional): Setting this to ``True`` will produce
                                   scrambled Sobol sequences. Scrambling is
                                   capable of producing better Sobol
                                   sequences. Default: ``False``.
        seed (Int, optional): This is the seed for the scrambling. The seed
                              of the random number generator is set to this,
                              if specified. Otherwise, it uses a random seed.
                              Default: ``None``

    Examples::

        >>> # xdoctest: +SKIP("unseeded random state")
        >>> soboleng = torch.quasirandom.SobolEngine(dimension=5)
        >>> soboleng.draw(3)
        tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
                [0.5000, 0.5000, 0.5000, 0.5000, 0.5000],
                [0.7500, 0.2500, 0.2500, 0.2500, 0.7500]])
       iR  FNc                    || j         k    s|dk     rt          d| j          d          || _        || _        || _        t          j        d          }t          j        || j        |t
          j	                  | _
        t          j        | j
        | j                   | j        s,t          j        | j        |t
          j	                  | _        n|                                  | j                            t
          j                  | _        | j        d| j        z  z                      dd          | _        d	| _        d S )
N   z9Supported range of dimensionality for SobolEngine is [1, ]cpu)devicedtype)memory_format   r   )MAXDIM
ValueErrorseedscramble	dimensiontorchr
   zerosMAXBITlong
sobolstate_sobol_engine_initialize_state_shift	_scrambleclonecontiguous_formatquasireshape_first_pointnum_generated)selfr   r   r   r	   s        i/var/www/html/bestrading.cuttalo.com/models/btc_v9/venv/lib/python3.11/site-packages/torch/quasirandom.py__init__zSobolEngine.__init__2   s.   t{""i!mm9*.+9 9 9  
 	 "l5!!+t{3ej
 
 
 	-dot~NNN} 	T^CuzRRRDJJNNZ%%E4K%LL
!Z!T[.8AA!RHH    r   noutr   returnc                 F   |t          j                    }| j        dk    r|dk    r| j                            |          }nt          j        | j        |dz
  | j        | j        | j        |          \  }| _        t          j	        | j                            |          |fd          }n9t          j        | j        || j        | j        | j        dz
  |          \  }| _        | xj        |z  c_        |*|
                    |                              |           |S |S )ak  
        Function to draw a sequence of :attr:`n` points from a Sobol sequence.
        Note that the samples are dependent on the previous samples. The size
        of the result is :math:`(n, dimension)`.

        Args:
            n (Int, optional): The length of sequence of points to draw.
                               Default: 1
            out (Tensor, optional): The output tensor
            dtype (:class:`torch.dtype`, optional): the desired data type of the
                                                    returned tensor.
                                                    Default: ``None``
        Nr   r   )r   )dim)r   get_default_dtyper!   r    to_sobol_engine_drawr   r   r   cat
resize_as_copy_)r"   r&   r'   r   results        r#   drawzSobolEngine.drawM   s4   & =+--E""Avv*--e44%*%=JEON&& & &"
 D$5$8$8$?$?#HbQQQ!&!9
"Q&" " "FDJ 	a?NN6""((000Jr%   mc                     d|z  }| j         |z   }||dz
  z  dk    s&t          d| j          d| j          d| d| d	          |                     |||	          S )
aI  
        Function to draw a sequence of :attr:`2**m` points from a Sobol sequence.
        Note that the samples are dependent on the previous samples. The size
        of the result is :math:`(2**m, dimension)`.

        Args:
            m (Int): The (base2) exponent of the number of points to draw.
            out (Tensor, optional): The output tensor
            dtype (:class:`torch.dtype`, optional): the desired data type of the
                                                    returned tensor.
                                                    Default: ``None``
        r   r   r   zFThe balance properties of Sobol' points require n to be a power of 2. z0 points have been previously generated, then: n=z+2**=zH. If you still want to do this, please use 'SobolEngine.draw()' instead.)r&   r'   r   )r!   r   r3   )r"   r4   r'   r   r&   total_ns         r#   
draw_base2zSobolEngine.draw_base2   s    $ qD$q(7Q;'1,,0)-);0 0151C0 0IJ0 0MT0 0 0   yy1#Uy333r%   c                 R    | j                             | j                   d| _        | S )zF
        Function to reset the ``SobolEngine`` to base state.
        r   )r   r1   r   r!   )r"   s    r#   resetzSobolEngine.reset   s)     	
$$$r%   c                     | j         dk    r0t          j        | j        |dz
  | j        | j        | j                    n/t          j        | j        || j        | j        | j         dz
             | xj         |z  c_         | S )a  
        Function to fast-forward the state of the ``SobolEngine`` by
        :attr:`n` steps. This is equivalent to drawing :attr:`n` samples
        without using the samples.

        Args:
            n (Int): The number of steps to fast-forward by.
        r   r   )r!   r   _sobol_engine_ff_r   r   r   )r"   r&   s     r#   fast_forwardzSobolEngine.fast_forward   s     ""#
AE4?DNDDV    #
At@RUV@V   	ar%   c                 ,   d }| j         -t          j                    }|                    | j                    t          j        d          }t          j        d| j        | j        f||          }t          j        |t          j	        dt          j
        d| j        |                              | _        | j        | j        | j        f}t          j        d|||                                          }t          j        | j        || j                   d S )Nr	   r   )r
   	generatorr   )r
   )r   r   	Generatormanual_seedr
   randintr   r   mvpowaranger   tril_sobol_engine_scramble_r   )r"   gr	   
shift_intsltm_dimsltms         r#   r   zSobolEngine._scramble   s    $(9 !!AMM$)$$$l5!! ],SA
 
 

 X	!U\!T[%M%M%MNN
 


 NDK=mAxqAAAFFHH%dosDNKKKKKr%   c                     d| j          g}| j        r|dgz  }| j        |d| j         gz  }| j        j        dz   d                    |          z   dz   S )Nz
dimension=zscramble=Truezseed=(z, ))r   r   r   	__class____name__join)r"   
fmt_strings     r#   __repr__zSobolEngine.__repr__   sq    34>334
= 	,?++J9 .49..//J~&,tyy/D/DDsJJr%   )FN)r   NN)NN)rP   
__module____qualname____doc__r   r   r$   intr   Tensorr   r3   r8   r:   r=   r   rS    r%   r#   r   r      s5       & &P FF   : #'$(	3 33 \D 3 {T!	3
 
3 3 3 3p $($(	4 44 \D 4 {T!	4
 
4 4 4 4<    (L L L,K K K K Kr%   r   )r   r   rY   r%   r#   <module>rZ      sV    RK RK RK RK RK RK RK RK RK RKr%   