o
    h                     @   s&   d dl mZ d dlZG dd dZdS )    )OptionalNc                	   @   s   e Zd ZdZdZdZdddZ			dd	ed
ee	j
 dee	j de	j
fddZ		dded
ee	j
 dee	j de	j
fddZdd Zdd Zdd Zd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                 C   s   || j ks	|dk rtd| j  d|| _|| _|| _td}tj|| j|tj	d| _
t| j
| j | jsCtj| j|tj	d| _n|   | jjtjd| _| jd| j  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    r!   e/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/quasirandom.py__init__3   s(   

zSobolEngine.__init__r   noutr	   returnc                 C   s   |du rt  }| jdkr:|dkr| j|}n6t j| j|d | j| j| j|d\}| _t j	| j||fdd}nt j| j|| j| j| jd |d\}| _|  j|7  _|durc|
|| |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	   resultr!   r!   r"   drawN   s6   
	zSobolEngine.drawmc              
   C   sX   d| }| j | }||d @ dks$td| j  d| j  d| d| d	| j|||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   r0   )r    r1   r%   r	   r$   total_nr!   r!   r"   
draw_base2   s   
zSobolEngine.draw_base2c                 C   s   | j | j d| _| S )zF
        Function to reset the ``SobolEngine`` to base state.
        r   )r   r.   r   r   )r    r!   r!   r"   reset   s   zSobolEngine.resetc                 C   sZ   | j dkrt| j|d | j| j| j  nt| j|| j| j| j d  |  j |7  _ | 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$   r!   r!   r"   fast_forward   s   
	zSobolEngine.fast_forwardc                 C   s   d }| j d urt }|| j  td}tjd| j| jf||d}t|t	dtj
d| j|d| _| j| j| jf}tjd|||d }t| 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ltmr!   r!   r"   r      s   

zSobolEngine._scramblec                 C   sT   d| j  g}| jr|dg7 }| jd ur|d| j g7 }| jjd d| d S )Nz
dimension=zscramble=Truezseed=(z, ))r   r   r   	__class____name__join)r    
fmt_stringr!   r!   r"   __repr__   s   

zSobolEngine.__repr__)FN)r   NN)NN)rH   
__module____qualname____doc__r   r   r#   intr   r   Tensorr	   r0   r4   r5   r7   r   rK   r!   r!   r!   r"   r      s@    (

8
r   )typingr   r   r   r!   r!   r!   r"   <module>   s   