示例#1
0
   void TestRandom(void)
/* ------------------------------------------------------------------
 * Use this (optional) function to test for a correct implementation.
 * ------------------------------------------------------------------    
 */
{
  long   i;
  long   x;
  double u;
  char   ok = 0;  

  SelectStream(0);                  /* select the default stream */
  PutSeed(1);                       /* and set the state to 1    */
  for(i = 0; i < 10000; i++)
    u = Random();
  GetSeed(&x);                      /* get the new state value   */
  ok = (x == CHECK);                /* and check for correctness */

  SelectStream(1);                  /* select stream 1                 */ 
  PlantSeeds(1);                    /* set the state of all streams    */
  GetSeed(&x);                      /* get the state of stream 1       */
  ok = ok && (x == A256);           /* x should be the jump multiplier */    
  if (ok)
    printf("\n The implementation of rngs.c is correct.\n\n");
  else
    printf("\n\a ERROR -- the implementation of rngs.c is not correct.\n\n");
}
示例#2
0
// This is the inititialization routine. This has to be called first!
CALMAPI::CALMAPI( void )
{
	// store stream defaults, since we will be manipulating width and precision
	GetStreamDefaults();
	
	// initialize the random number generator for the E-node activation
	SetSeed( GetSeed() );
	
	// store the current working directory
	getcwd( mCALMCurDir, FILENAME_MAX );
	strcpy( mCALMLogDir, mCALMCurDir );		// init log dir to same dir
	
	// Initialize and set the global network specifications data
	mNetwork = new CALMNetwork;	
	mInput = NULL;
	mInputLen = 0;
	mNumRuns = 1;
	mNumEpochs = 50;
	mNumIterations = 100;
	mOrder = kPermuted;
    mVerbosity = O_WINNER;
    mConvstop = false;
	mFBOn = false;
	strcpy( mBasename, "calm" );
	strcpy( mDirname, "." );
	mLogFile = NULL;
	mCALMLog = &cout;
}
示例#3
0
void IntensityTransformer::Apply(cv::Mat &mat)
{
    auto seed = GetSeed();
    auto rng = m_rngs.pop_or_create([seed]() { return std::make_unique<std::mt19937>(seed); } );

    // Using single precision as EigVal and EigVec matrices are single precision.
    std::normal_distribution<float> d(0, (float)m_curStdDev);
    cv::Mat alphas(1, 3, CV_32FC1);
    assert(m_eigVal.rows == 1 && m_eigVec.cols == 3);
    alphas.at<float>(0) = d(*rng) * m_eigVal.at<float>(0);
    alphas.at<float>(1) = d(*rng) * m_eigVal.at<float>(1);
    alphas.at<float>(2) = d(*rng) * m_eigVal.at<float>(2);
    m_rngs.push(std::move(rng));

    assert(m_eigVec.rows == 3 && m_eigVec.cols == 3);

    cv::Mat shifts = m_eigVec * alphas.t();

    // For multi-channel images data is in BGR format.
    size_t cdst = mat.rows * mat.cols * mat.channels();
    ElemType* pdstBase = reinterpret_cast<ElemType*>(mat.data);
    for (ElemType* pdst = pdstBase; pdst < pdstBase + cdst;)
    {
        for (int c = 0; c < mat.channels(); c++)
        {
            float shift = shifts.at<float>(mat.channels() - c - 1);
            *pdst = std::min(std::max(*pdst + shift, (ElemType)0), (ElemType)255);
            pdst++;
        }
    }
}
示例#4
0
void CropTransformer::Apply(uint8_t copyId, cv::Mat &mat)
{
    auto seed = GetSeed();
    auto rng = m_rngs.pop_or_create([seed]() { return std::make_unique<std::mt19937>(seed); }); 
    int viewIndex = m_cropType == CropType::MultiView10 ? (int)(copyId % ImageDeserializerBase::NumMultiViewCopies) : 0;

    switch (m_cropType)
    {
    case CropType::Center: 
        mat = mat(GetCropRectCenter(mat.rows, mat.cols, *rng));
        break; 
    case CropType::RandomSide: 
        mat = mat(GetCropRectRandomSide(mat.rows, mat.cols, *rng)); 
        break; 
    case CropType::RandomArea: 
        mat = mat(GetCropRectRandomArea(mat.rows, mat.cols, *rng));
        break;
    case CropType::MultiView10: 
        mat = mat(GetCropRectMultiView10(viewIndex, mat.rows, mat.cols, *rng));
        break; 
    default: 
        RuntimeError("Invalid crop type."); 
        break; 
    }

    // for MultiView10 m_hFlip is false, hence the first 5 will be unflipped, the later 5 will be flipped
    if ((m_hFlip && boost::random::bernoulli_distribution<>()(*rng)) ||
        viewIndex >= 5)
    {
        cv::flip(mat, mat, 1);
    }

    m_rngs.push(std::move(rng));
}
示例#5
0
void ScaleTransformer::Apply(cv::Mat &mat)
{
    // If matrix has not been converted to the right type, do it now as rescaling
    // requires floating point type.
    //
    if (mat.type() != CV_MAKETYPE(m_dataType, m_imgChannels))
    {
        mat.convertTo(mat, m_dataType);
    }

    auto seed = GetSeed();
    auto rng = m_rngs.pop_or_create(
        [seed]()
        {
            return std::make_unique<std::mt19937>(seed);
        });


    auto index = UniIntT(0, static_cast<int>(m_interp.size()) - 1)(*rng);
    assert(m_interp.size() > 0);
    cv::resize(
        mat, mat,
        cv::Size(static_cast<int>(m_imgWidth), static_cast<int>(m_imgHeight)), 0,
        0, m_interp[index]);

    m_rngs.push(std::move(rng));
}
void Library_spot_native_Microsoft_SPOT_CryptoState::GetDeviceKey( RSAKey& key )
{
    KeySeed keySeed;

    GetSeed( keySeed );

    ::Crypto_GeneratePrivateKey( &keySeed, &key );
}
void Library_spot_native_Microsoft_SPOT_CryptoState::GetDeviceKey( UINT8* key )
{
    KeySeed keySeed;

    GetSeed( keySeed );

    ::GetC1Value( (BYTE*)&keySeed, key, TEA_KEY_SIZE_BYTES );
}
示例#8
0
void GalaxySetupPanel::GetSetupData(GalaxySetupData& setup_data) const {
    setup_data.m_seed =             GetSeed();
    setup_data.m_size =             Systems();
    setup_data.m_shape =            GetShape();
    setup_data.m_age =              GetAge();
    setup_data.m_starlane_freq =    GetStarlaneFrequency();
    setup_data.m_planet_density =   GetPlanetDensity();
    setup_data.m_specials_freq =    GetSpecialsFrequency();
    setup_data.m_monster_freq =     GetMonsterFrequency();
    setup_data.m_native_freq =      GetNativeFrequency();
    setup_data.m_ai_aggr =          GetAIAggression();
}
示例#9
0
  void TestRandom(void)
/* 
 * Use this (optional) procedure to test for a correct implementation.    
 */
{
  long   i;
  long   x;
  double u;

  PutSeed(1);                                /* set initial state to 1 */
  for(i = 0; i < 10000; i++)
    u = Random();
  GetSeed(&x);                               /* get the new state      */
  if (x == CHECK) 
    printf("\n The implementation of Random is correct\n");
  else
    printf("\n\a ERROR - the implementation of Random is not correct\n");
}
示例#10
0
void mexFunction(int nlhs, mxArray *plhs[],
		 int nrhs, const mxArray *prhs[])
{
  int ndims, len, i;
  int *dims;
  double *indata, *outdata;
  long ix,iy,iz;

  if((nlhs > 1) || (nrhs > 1))
    mexErrMsgTxt("Usage: seed = randomseed; (or) randomseed(new_seed);");

  if(nrhs > 0) {
    /* prhs[0] is first argument.
     * mxGetPr returns double*  (data, col-major)
     */
    ndims = mxGetNumberOfDimensions(prhs[0]);
    dims = (int*)mxGetDimensions(prhs[0]);
    indata = mxGetPr(prhs[0]);
    len = mxGetNumberOfElements(prhs[0]);

    if(mxIsSparse(prhs[0]))
      mexErrMsgTxt("Cannot handle sparse matrices.  Sorry.");

    if(len == 1 && *indata == 0.0) {
      ResetSeed();
    } else if(len != 3) {
      mexErrMsgTxt("seed must be 0 or a vector of 3 numbers.");
    } else {
      SetSeed((long)indata[0],(long)indata[1],(long)indata[2]);
    }
  }
  ndims = 1;
  dims = (int*)mxMalloc(sizeof(int));
  dims[0] = 3;
  /* plhs[0] is first output */
  plhs[0] = mxCreateNumericArray(ndims, dims, mxDOUBLE_CLASS, mxREAL);
  outdata = mxGetPr(plhs[0]);
  GetSeed(&ix,&iy,&iz);
  outdata[0] = (double)ix;
  outdata[1] = (double)iy;
  outdata[2] = (double)iz;  
}
示例#11
0
// This is the inititialization routine. This has to be called first!
SequenceAPI::SequenceAPI( void )
{
	// store stream defaults, since we will be manipulating width and precision
	GetStreamDefaults();

	// initialize the random number generator for noise
	SetSeed( GetSeed() );
	
	// store the current working directory
	getcwd( mSequenceCurDir, FILENAME_MAX );
	strcpy( mSequenceLogDir, mSequenceCurDir );		// init log dir to same dir
	
	mPatterns = new Patterns();	// this just sets an empty pattern class
	
	// set defaults for the network specifications
	strcpy( mBasename, "seq" );
	strcpy( mDirname, "." );
	mNumFiles = 1;
	mFileIndex = 0;
	mRuns = 1;
	mEpochs = 1000;
	mIterations = 10;
	mRecallLen = 100;
	mNumLayers = 8;
	mLayerSize = 16;
	mContextSize = 16;
	mOrder = kPermutedOrder;
	mType = O_INF;
    mVerbosity = O_ERROR;
	mErrCrit = 0.1;
	mAlphaCrit = 0.01;
	mRecallCrit = 0.05;
	mTermNoise = 0.05;
	mError = -1.0;
	mOldInput   = NULL;
	mNewInput   = NULL;
	mInContext  = NULL;
	mTextDisplay = NULL;
	mNetwork = NULL;
	mNoise = NULL;
	mSequenceLog = &cout;
}
示例#12
0
void BombObject::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
	{
	this->ip = ip;
	
	if (!hParam) {
		hSot = ip->AddRollupPage( 
				hInstance, 
				MAKEINTRESOURCE(IDD_BOMB_SOT),
				DefaultSOTProc,
				GetString(IDS_RB_SOT), 
				(LPARAM)ip,APPENDROLL_CLOSED);

		hParam = ip->AddRollupPage( 
				hInstance, 
				MAKEINTRESOURCE(IDD_BOMBPARAMS),
				BombParamProc,
				GetString(IDS_RB_BOMBPARAMS), 
				(LPARAM)this );
	} else {
      DLSetWindowLongPtr(hParam, this);      

		// Init the dialog to our values.
		strengthSpin->SetValue(GetStrength(ip->GetTime()),FALSE);
		gravSpin->SetValue(GetGravity(ip->GetTime()),FALSE );
		chaosSpin->SetValue(GetChaos(ip->GetTime()),FALSE );
		detSpin->SetValue(GetDetonation(ip->GetTime()),FALSE );
		spinSpin->SetValue(GetSpin(ip->GetTime()),FALSE);
		falloffSpin->SetValue(GetFalloff(ip->GetTime()),FALSE);
		minFragSpin->SetValue(GetMinFrag(ip->GetTime()),FALSE);
		maxFragSpin->SetValue(GetMaxFrag(ip->GetTime()),FALSE);
		seedSpin->SetValue(GetSeed(ip->GetTime()),FALSE);
		CheckDlgButton(hParam,IDC_FALLOFF_ON,GetFalloffOn(ip->GetTime()));
		}

	if (GetFalloffOn(ip->GetTime())) {
		NotifyDependents(FOREVER,0,REFMSG_CHANGE);
		ip->RedrawViews(ip->GetTime());
		}
	}
示例#13
0
void CropTransformer::Apply(cv::Mat &mat)
{
    auto seed = GetSeed();
    auto rng = m_rngs.pop_or_create(
        [seed]()
        {
            return std::make_unique<std::mt19937>(seed);
        });

    double ratio = 1;
    switch (m_jitterType)
    {
    case RatioJitterType::None:
        ratio = m_cropRatioMin;
        break;
    case RatioJitterType::UniRatio:
        if (m_cropRatioMin == m_cropRatioMax)
        {
            ratio = m_cropRatioMin;
        }
        else
        {
            ratio = UniRealT(m_cropRatioMin, m_cropRatioMax)(*rng);
            assert(m_cropRatioMin <= ratio && ratio < m_cropRatioMax);
        }
        break;
    default:
        RuntimeError("Jitter type currently not implemented.");
    }

    mat = mat(GetCropRect(m_cropType, mat.rows, mat.cols, ratio, *rng));
    if (m_hFlip && std::bernoulli_distribution()(*rng))
    {
        cv::flip(mat, mat, 1);
    }

    m_rngs.push(std::move(rng));
}
示例#14
0
void ColorTransformer::Apply(cv::Mat &mat)
{
    auto seed = GetSeed();
    auto rng = m_rngs.pop_or_create([seed]() { return std::make_unique<std::mt19937>(seed); });

    if (m_curBrightnessRadius > 0 || m_curContrastRadius > 0)
    {
        // To change brightness and/or contrast the following standard transformation is used:
        // Xij = alpha * Xij + beta, where
        // alpha is a contrast adjustment and beta - brightness adjustment.
        ElemType beta = 0;
        if (m_curBrightnessRadius > 0)
        {
            UniRealT d(-m_curBrightnessRadius, m_curBrightnessRadius);
            // Compute mean value of the image.
            cv::Scalar imgMean = cv::sum(cv::sum(mat));
            // Compute beta as a fraction of the mean.
            beta = (ElemType)(d(*rng) * imgMean[0] / (mat.rows * mat.cols * mat.channels()));
        }

        ElemType alpha = 1;
        if (m_curContrastRadius > 0)
        {
            UniRealT d(-m_curContrastRadius, m_curContrastRadius);
            alpha = (ElemType)(1 + d(*rng));
        }

        // Could potentially use mat.convertTo(mat, -1, alpha, beta) 
        // but it does not do range checking for single/double precision matrix. saturate_cast won't work either.
        size_t count = mat.rows * mat.cols * mat.channels();
        ElemType* pbase = reinterpret_cast<ElemType*>(mat.data);
        for (ElemType* p = pbase; p < pbase + count; p++)
        {
            *p = std::min(std::max(*p * alpha + beta, (ElemType)0), (ElemType)255);
        }
    }

    if (m_curSaturationRadius > 0 && mat.channels() == 3)
    {
        UniRealT d(-m_curSaturationRadius, m_curSaturationRadius);
        double ratio = 1.0 + d(*rng);
        assert(0 <= ratio && ratio <= 2);

        auto hsv = m_hsvTemp.pop_or_create([]() { return std::make_unique<cv::Mat>(); });

        // To change saturation, we need to convert the image to HSV format first,
        // the change S channgel and convert the image back to BGR format.
        cv::cvtColor(mat, *hsv, CV_BGR2HSV);
        assert(hsv->rows == mat.rows && hsv->cols == mat.cols);
        size_t count = hsv->rows * hsv->cols * mat.channels();
        ElemType* phsvBase = reinterpret_cast<ElemType*>(hsv->data);
        for (ElemType* phsv = phsvBase; phsv < phsvBase + count; phsv += 3)
        {
            const int HsvIndex = 1;
            phsv[HsvIndex] = std::min((ElemType)(phsv[HsvIndex] * ratio), (ElemType)1);
        }
        cv::cvtColor(*hsv, mat, CV_HSV2BGR);

        m_hsvTemp.push(std::move(hsv));
    }

    m_rngs.push(std::move(rng));
}
示例#15
0
void testAdventurer (struct gameState *after)
{
	int numTreasureDrawn = 0;
	int numNonTreasureDrawn = 0;
	int nonTreasureSaved;
	int cardDrawn;
	int temphand[MAX_HAND];
	int result,  randomDeterminer;
	int handPos = floor(Random() * after->handCount[after->whoseTurn]);
	// Sets up call to random number generator
	long *x = malloc(sizeof(long));
	struct gameState before;

	//Copy two gameStates so that they can be compared later
	memcpy(&before, after, sizeof(struct gameState));

	randomDeterminer = floor(Random() * 10);
	if (randomDeterminer <= 5)
		after->deckCount[after->whoseTurn] = 0;

	// Gets seed so random number sequence can be repeated for before gameState
	GetSeed(x);

	//Testing adventurer refactored on after gameState
	result = cardEffect(adventurer, 0, 0, 0, after, handPos, 0);

	// Enters seed so that random number sequence will be the same for post gameState
	PutSeed(*x);
	
	//Give gameState before the correct implementation of Adventurer

	while (numTreasureDrawn < 2)
	{
		if (before.deckCount[before.whoseTurn] < 1) //shuffle discard
		{
			shuffle(before.whoseTurn, &before);
		}

		drawCard(before.whoseTurn, &before);
		cardDrawn = before.hand[before.whoseTurn][before.handCount[before.whoseTurn] - 1];

		if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold)
		{
			numTreasureDrawn++;
		}
		else
		{
			temphand[numNonTreasureDrawn] = cardDrawn;
			before.handCount[before.whoseTurn]--; //Remove (discard) if not treasure
			numNonTreasureDrawn++;
		}
	}

	nonTreasureSaved = numNonTreasureDrawn;

	//Number of cards in discard pile before adding temp hand
	int discardCountBeforeExecution = before.discardCount[before.whoseTurn];

	while (numNonTreasureDrawn - 1 >= 0)
	{
		before.discard[before.whoseTurn][before.discardCount[before.whoseTurn]++] = temphand[numNonTreasureDrawn-1];
		numNonTreasureDrawn--;
	}

	//Now, compare to after, should equal old + number of non-treasure cards drawn
	int discardCountAfterExecution = before.discardCount[before.whoseTurn];
	assert(discardCountAfterExecution == discardCountBeforeExecution + nonTreasureSaved);

	//Now, check that the function returned correctly and the gameStates are equal
	assert(result == 0);

	//Should fail (in refactor, gives 3 treasure cards)
	if (memcmp(&before, after, sizeof(struct gameState)) != 0)
	{
		printf("Game states were not equal (bug(s) present)!\n");
		exit(0);
	}

	return;

}
示例#16
0
文件: Diag.c 项目: uincore/OpenSAR
Std_ReturnType Diag_GetSeedEXTDS(uint8 *securityAccessDataRecord, uint8 *seed, Dcm_NegativeResponseCodeType *errorCode)
{
	return GetSeed(securityAccessDataRecord,seed,errorCode);
}