
    Pg                     ,    d dl mZ d dlZ G d d      Zy)    )OptionalNc            	          e Zd ZdZdZdZddZ	 	 	 ddedee	j                     dee	j                     d	e	j                  fd
Z	 	 ddedee	j                     dee	j                     d	e	j                  fdZd Zd Zd Zd Zy)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  Nc                    || j                   kD  s|dk  rt        d| j                    d      || _        || _        || _        t        j                  d      }t        j                  || j                  |t
        j                        | _
        t        j                  | j                  | j                         | j                  s6t        j                  | j                  |t
        j                        | _        n| j                          | j                  j                  t
        j                        | _        | j                   d| j                  z  z  j#                  dd      | _        d	| _        y )
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        X/var/www/html/suriana-translation/venv/lib/python3.12/site-packages/torch/quasirandom.py__init__zSobolEngine.__init__3   s   t{{"i!m**.++a9 
 	 "ll5!++t{{3ejj
 	--doot~~N}}T^^CuzzRDJNNZZ%%E4K4K%L
!ZZ!T[[.8AA!RH    noutr   returnc                    |t        j                         }| j                  dk(  r|dk(  r| j                  j	                  |      }nt        j
                  | j                  |dz
  | j                  | j                  | j                  |      \  }| _        t        j                  | j                  j	                  |      |fd      }nNt        j
                  | j                  || j                  | j                  | j                  dz
  |      \  }| _        | xj                  |z  c_        |"|j                  |      j                  |       |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``
        r   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.drawN   s"   & =++-E"Av**--e4%*%=%=JJEOONN&&&"
 D$5$5$8$8$?#HbQ!&!9!9

""Q&"FDJ 	a?NN6"((0Jr&   mc                     d|z  }| j                   |z   }||dz
  z  dk(  s,t        d| j                    d| j                    d| d| d	      | j                  |||	      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   r4   )r#   r5   r(   r   r'   total_ns         r$   
draw_base2zSobolEngine.draw_base2   s    $ qD$$q(7Q;'1,))-););(< =1151C1C0DD1WI V00  yy1#Uy33r&   c                 ^    | j                   j                  | j                         d| _        | S )zF
        Function to reset the ``SobolEngine`` to base state.
        r   )r   r2   r   r"   )r#   s    r$   resetzSobolEngine.reset   s'     	

$r&   c                 `   | j                   dk(  rEt        j                  | j                  |dz
  | j                  | j
                  | j                          nDt        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??DNNDDVDV ##

At@R@RUV@V 	ar&   c                    d }| j                   /t        j                         }|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|||      j                         }t        j                  | j                  || j                         y )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    '+99 !AMM$))$ll5! ]],SA

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

 NNDKK=mmAxqAFFH%%doosDNNKr&   c                     d| j                    g}| j                  r|dgz  }| j                  |d| j                   gz  }| j                  j                  dz   dj                  |      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__   st    "4>>"234
==?++J99 U499+.//J~~&&,tyy/DDsJJr&   )FN)r   NN)NN)rQ   
__module____qualname____doc__r   r   r%   intr   r   Tensorr   r4   r9   r;   r>   r   rT    r&   r$   r   r      s    &P FF: &*'+	33 ell#3 $	3
 
3p '+'+	44 ell#4 $	4
 
4<(L,Kr&   r   )typingr   r   r   rZ   r&   r$   <module>r\      s     RK RKr&   