Randomizer.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2019 Vishwesh Venkatraman <vishwesh.venkatraman@ntnu.no>
 * 
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.utils;
 
import java.util.Collection;
import java.util.List;
 
import javax.vecmath.Point3d;
 
import org.apache.commons.math3.random.MersenneTwister;
 
import denoptim.exception.DENOPTIMException;
import denoptim.io.DenoptimIO;
 
public class Randomizer
{
    private long rndSeed = 0L;
    
    private MersenneTwister mt = null;
    
    private final boolean debug = false;
    
//------------------------------------------------------------------------------
    
    public Randomizer()
    {
        initialiseRNG();
    }
    
//------------------------------------------------------------------------------
    
    public Randomizer(long seed)
    {
        initialiseRNG(seed);
    }
 
//------------------------------------------------------------------------------
 
    private void setSeed(long value)
    {
        rndSeed = value;
    }
 
//------------------------------------------------------------------------------
 
    public long getSeed()
    {
        return rndSeed;
    }
    
//------------------------------------------------------------------------------
 
    public void initialiseRNG()
    {
        initialiseSeed();
        mt = new MersenneTwister(rndSeed);
    }
    
//------------------------------------------------------------------------------
 
    public void initialiseRNG(long seed)
    {
        setSeed(seed);
        mt = new MersenneTwister(rndSeed);
    }
    
//------------------------------------------------------------------------------
 
    private MersenneTwister getRNG()
    {
        if (mt == null)
        {
            initialiseRNG();
        }
        return mt;
    }
    
//------------------------------------------------------------------------------
 
    private void print(Object val, String type)
    {
        String sss = "asked for "+ type + " "+val.toString();
        if (true)
        {
            Exception ex = new Exception();
            for (int i=0; i<5;i++)
            {
                String cn = ex.getStackTrace()[i].getClassName();
                if (!cn.contains("RandomUtils"))
                {
                    sss = sss + ex.getStackTrace()[i].getClassName() + ":" 
                            + ex.getStackTrace()[i].getLineNumber()+" ";
                }
            }
        }
        
        try
        {
            DenoptimIO.writeData("/tmp/rng_debug_log",sss,true);
        } catch (DENOPTIMException e)
        {
            e.printStackTrace();
        }
    }
    
//------------------------------------------------------------------------------
 
    public double nextDouble()
    {
        double d = getRNG().nextDouble();
        if (debug)
            print(d,"double");
        return d;
    }
    
//------------------------------------------------------------------------------
 
    public double nextNormalDouble()
    {
        double d = getRNG().nextGaussian();
        if (debug)
            print(d,"double");
        return d;
    }
    
//------------------------------------------------------------------------------
 
    public int nextInt(int i)
    {
        int r = getRNG().nextInt(i);
        if (debug)
            print(r,"int");
        return r;
    }
    
//------------------------------------------------------------------------------
 
    public boolean nextBoolean()
    {
        boolean r = getRNG().nextBoolean();
        if (debug)
            print(r,"boolean");
        return r;
    }
    
//------------------------------------------------------------------------------
 
    public boolean nextBoolean(double prob)
    {
        return nextDouble() < prob;
    }
    
//------------------------------------------------------------------------------
    public Point3d getNoisyPoint(double maxAbsValue)
    {
        double xFactor = nextDouble();
        double yFactor = nextDouble();
        double zFactor = nextDouble();
        double xSign = nextBoolean() ? 1.0 : -1.0;
        double ySign = nextBoolean() ? 1.0 : -1.0;
        double zSign = nextBoolean() ? 1.0 : -1.0;
 
        return new Point3d(maxAbsValue*xFactor*xSign,
                maxAbsValue*yFactor*ySign,
                maxAbsValue*zFactor*zSign);
    }
    
//------------------------------------------------------------------------------
 
    public Point3d getNormallyNoisyPoint(double maxAbsValue)
    {
        double xFactor = 2*nextNormalDouble()-1;
        double yFactor = 2*nextNormalDouble()-1;
        double zFactor = 2*nextNormalDouble()-1;
 
        return new Point3d(maxAbsValue*xFactor,
                maxAbsValue*yFactor,
                maxAbsValue*zFactor);
    }
      
//------------------------------------------------------------------------------
    
    public <T> T randomlyChooseOne(Collection<T> c)
    {
        if (c.size() == 0)
            return null;
        
        int chosen = nextInt(c.size());
        int i=0;
        T chosenObj = null;
        for (T o : c)
        {
            if (i == chosen)
            {
                chosenObj = o;
            }
            i++;
        }
        return chosenObj;
    }
 
//------------------------------------------------------------------------------
 
    public <T> void shuffle(List<T> list)
    {
        for (int i = list.size() - 1; i > 0; i--)
        {
            int j = nextInt(i + 1);
            T tmp = list.get(i);
            list.set(i, list.get(j));
            list.set(j, tmp);
        }
    }
 
//------------------------------------------------------------------------------
 
    private void initialiseSeed()
    {
        // WARNING: The SecureRandom implementation in Linux is usable only
        // once, then it becomes terribly slow: 1-2 minutes to get a seed!!!
        
        /*
        SecureRandom sec = new SecureRandom();
        byte[] sbuf = sec.generateSeed(8);
        ByteBuffer bb = ByteBuffer.wrap(sbuf);
        rndSeed = bb.getLong();
        */
        rndSeed = System.currentTimeMillis();
    }
 
//------------------------------------------------------------------------------
 
}