void ribi::SimpleLinearRegression::Test() noexcept
{
  {
    static bool is_tested { false };
    if (is_tested) return;
    is_tested = true;
  }
  const TestTimer test_timer(__func__,__FILE__,1.0);
  {
    const std::vector<double> v { 75.0, 83.0, 96.0, 100.0, 121.0, 125.0 };
    const double variance { CalculateVariance(v) };
    const double expected { 332.666667 };
    assert(std::abs(variance - expected) < 0.0001);
  }
  {
    const std::vector<double> v { 0.23, 0.37, 0.45, 0.49, 0.56, 0.63, 0.63, 0.70, 0.72, 0.82 };
    const double variance { CalculateVariance(v) };
    const double expected { 0.02846 };
    assert(std::abs(variance - expected) < 0.0001);
  }
  for (int i=1; i!=5; ++i) //Human-based counting, following the Ansombe's Quartet indices
  {
    const std::vector<double> xs { GetAnscombesQuartetX(i) };
    const std::vector<double> ys { GetAnscombesQuartetY(i) };
    const std::pair<double,double> p { CalculateBestFit(xs,ys) };

    const double mean_x { CalculateMean(xs) };
    const double mean_y { CalculateMean(ys) };
    const double slope { p.first };
    const double intercept { p.second };

    //const double variance_x = CalculateVariance(xs);
    //const double variance_y = CalculateVariance(ys);


    const double expected_mean_x { 9.0 };
    const double expected_mean_y { 7.5 };     //to 2 decimal places
    const double expected_slope  { 0.500 };   //to 3 decimal places
    const double expected_intercept { 3.00 }; //to 2 decimal places

    const double e { 0.01 };
    assert(std::abs(expected_mean_x - mean_x) < e);
    assert(std::abs(expected_mean_y - mean_y) < e);

    //const double expected_variance_x = 11.0;
    //const double expected_variance_y = 4.125;        //4.122 or 4.127 (to 3 decimal places)
    //const double expected_correlation = 0.816;       //to 3 decimal places)
    //assert(std::abs(expected_variance_x - variance_x) < e);
    //assert(std::abs(expected_variance_y - variance_y) < e);
    assert(std::abs(expected_slope - slope) < e);
    assert(std::abs(expected_intercept - intercept) < e);
  }
}
예제 #2
0
void Glicko2::calculateNewRatings(Player &player, const std::vector<Match> &matches, const float factor)
{
  const Player old = player;
  // Step 1: done by Player initialization
  // Step 2: done by setRating and setRd

  // Step 3
  const float v = CalculateVariance(player, matches);

  // Step 4 & 5
  player.volatility = newVolatility(player, matches, v);

  // Step 6
  player.deviation = preRatingRD(player.deviation, player.volatility);

  // Step 7
  player.deviation = 1 / sqrt((1 / pow(player.deviation, 2)) + (1 / v));

  float rd_sum = 0;
  const Player * opponent;
  
  for (auto it = matches.begin(); it != matches.end(); ++it)
  {
    opponent = it->opponent;
    rd_sum += g(opponent->deviation) * (it->result - E(player.rating, opponent->rating, opponent->deviation));
  }

  player.rating = pow(player.deviation, 2) * rd_sum;

  // Step 8: Done by getRating and GetRd

  //adjust the values based on the factor used
  player.volatility = (player.volatility - old.volatility) * factor + old.volatility;
  player.deviation = (player.deviation - old.deviation) * factor + old.deviation;
  player.rating = (player.rating - old.rating) * factor + old.rating;
}
예제 #3
0
double FindCoverageProbability( const double* gapest, const double* gbar, const int numCIs, const double numNonOverBatches, const int numBatches, const double za, const double OptGap, const int degreesFreedom, ofstream& debugFile, double* var, double* gapbar )
{
   int      repCounter;
            //ii;
   double   //gapsum = 0,
            //gbar = 0,
            svar = 0,
            coverage = 0;
   double //* var,
          * CI;
   int    * check;
   bool     varPassed;     // true if var was passed in as an argument

   // gapbar  = new double [numCIs]; 
   if( !var )
   {
      varPassed = false;
      var  = new double [numCIs]; 
   }
   else
      varPassed = true;
   CI      = new double [numCIs]; 
   check   = new int    [numCIs]; 

   coverage = 0;
   for( repCounter = 0; repCounter < numCIs; repCounter++ )
   {
      //calculate gapbar (average gap of numBatches replications)

      // This is the average of the overlapping gaps, which doesn't put enough emphasis on samples near either end of the distribution.
      // This needs to be changed somehow...  Maybe an average of non-overlapping batches?  Enforce n = km?
      //gapsum = 0.0; 
      //for( ii = (repCounter*numBatches); ii < (repCounter*numBatches)+numBatches; ii++ )
         //gapsum += gapest[ii]; 
      
      //gbar = (double) gapsum / (double) numBatches; 
      //cout << "gbar = " << gbar << endl;
      //cout << gbar << endl;
      // gapbar[repCounter]  = gbar; 

      //calculate variance of the gap in numBatches replications 

      svar   = CalculateVariance( gapest, gbar[repCounter], numBatches, repCounter, degreesFreedom); 
      var[repCounter] = svar; 


      //calculate CI and fill in check, update coverage
      
      CI[repCounter] = gbar[repCounter] + za * sqrt(svar) / sqrt(numNonOverBatches); 

      
      if( CI[repCounter] < OptGap )
         check[repCounter] = 0; 
      else 
         check[repCounter] = 1; 

      coverage += check[repCounter]; 
   }
   coverage /= numCIs; 

   // return the average gap estimate, if it was passed in
   //if( gapbar )
      //*gapbar = gbar;


#if DEBUG_COVER
   int totssize = numBatches * numCIs;
   debugFile<<endl<<"Gap Estimate"<<endl; 
   debugFile<<"------------"<<endl; 
   for(repCounter=0; repCounter<totssize; repCounter++)
      debugFile<<gapest[repCounter]<<endl; 

   // debugFile<<endl<<"ZnStar"<<endl; 
   // debugFile<<"---------"<<endl; 
   // for(repCounter=0; repCounter<totssize; repCounter++)
      // debugFile<<zn[repCounter]<<endl; 

   // debugFile<<endl<<"ExpCost Estimate"<<endl; 
   // debugFile<<"------------------"<<endl; 
   // for(repCounter=0; repCounter<totssize; repCounter++)
      // debugFile<<expCost[repCounter]<<endl; 


   debugFile<<endl; 


   // debugFile<<endl<<"Gap_Bar"<<endl; 
   // debugFile<<"------------"<<endl; 
   // for(repCounter=0; repCounter<numCIs; repCounter++)
      // debugFile<<gapbar[repCounter]<<endl; 

   debugFile<<endl<<"Var estimate"<<endl; 
   debugFile<<"---------------"<<endl; 
   for(repCounter=0; repCounter<numCIs; repCounter++)
      debugFile<<var[repCounter]<<endl; 

   debugFile<<endl<<"CI Estimate"<<endl; 
   debugFile<<"------------------"<<endl; 
   for(repCounter=0; repCounter<numCIs; repCounter++)
      debugFile<<CI[repCounter]<<endl; 
   
   debugFile<<endl<<"Checks of CI"<<endl; 
   debugFile<<"------------------"<<endl; 
   for(repCounter=0; repCounter<numCIs; repCounter++)
      debugFile<<check[repCounter]<<endl; 
   debugFile.close();
#endif

   // if (gapbar)  delete [] gapbar; 
   if( !varPassed )
      if (var)     delete [] var; 
   if (CI)      delete [] CI; 
   if (check)   delete [] check; 
   // gapbar  = NULL; 
   if( !varPassed )
      var     = NULL; 
   CI      = NULL;
   check   = NULL;

   return coverage;
} // end of FindCoverageProbability
effVOID EFF3DTerrainROAMImproveTileData::GenerateGeometryDataFromElevationMap(effUINT16 * pEM, effUINT16 * pError, effINT nLevel)
{
    effBOOL * pVerticesUsed = new effBOOL[TERRAIN_TILE_PIXEL_SIZE * TERRAIN_TILE_PIXEL_SIZE];
    memset(m_nIndicesNum, 0, sizeof(effINT) * 4);
    memset(m_nVerticesNum, 0, sizeof(effINT) * 4);

    for ( effINT i = 0; i < nLevel; i++ )
    {

        TriTreeNode * pLeftNode = new TriTreeNode();
        TriTreeNode * pRightNode = new TriTreeNode();
        TriTreeNode * pTopNode = new TriTreeNode();
        TriTreeNode * pBottomNode = new TriTreeNode();

        effINT nGridNum = TERRAIN_TILE_PIXEL_SIZE - 1;

        effINT nCenterX = nGridNum / 2;
        effINT nCenterZ = nGridNum / 2;






        pLeftNode->Set(AL, nCenterX, nCenterZ, 0, 0, 0, nGridNum, pTopNode, NULL, NULL, NULL, pTopNode, pBottomNode, NULL);
        pBottomNode->Set(AL, nCenterX, nCenterZ, 0, nGridNum, nGridNum, nGridNum, NULL, pRightNode, NULL, NULL, pLeftNode, pRightNode, NULL);
        pRightNode->Set(AL, nCenterX, nCenterZ, nGridNum, nGridNum, nGridNum, 0, pBottomNode, pTopNode, NULL, NULL, pBottomNode, pTopNode, NULL);
        pTopNode->Set(AL, nCenterX, nCenterZ, nGridNum, 0, 0, 0, pRightNode, pLeftNode, NULL, NULL, pRightNode, pLeftNode, NULL);



        effINT varianceCount = TERRAIN_TILE_VARIANCE_NODE_NUM;

        effUINT16 * pLeftVariance = EFFNEW effUINT16[varianceCount];
        memset(pLeftVariance, 0, sizeof(effUINT16) * varianceCount);
        CalculateVariance(pEM, pLeftVariance, pLeftNode->nApexX, pLeftNode->nApexZ, pLeftNode->nLeftX, pLeftNode->nLeftZ,
                          pLeftNode->nRightX, pLeftNode->nRightZ, 1);

        effUINT16 * pBottomVariance = EFFNEW effUINT16[varianceCount];
        memset(pBottomVariance, 0, sizeof(effUINT16) * varianceCount);
        CalculateVariance(pEM, pBottomVariance, pBottomNode->nApexX, pBottomNode->nApexZ, pBottomNode->nLeftX, pBottomNode->nLeftZ,
                          pBottomNode->nRightX, pBottomNode->nRightZ, 1);

        effUINT16 * pRightVariance = EFFNEW effUINT16[varianceCount];
        memset(pRightVariance, 0, sizeof(effUINT16) * varianceCount);
        CalculateVariance(pEM, pRightVariance, pRightNode->nApexX, pRightNode->nApexZ, pRightNode->nLeftX, pRightNode->nLeftZ,
                          pRightNode->nRightX, pRightNode->nRightZ, 1);

        effUINT16 * pTopVariance = EFFNEW effUINT16[varianceCount];
        memset(pTopVariance, 0, sizeof(effUINT16) * varianceCount);
        CalculateVariance(pEM, pTopVariance, pTopNode->nApexX, pTopNode->nApexZ, pTopNode->nLeftX, pTopNode->nLeftZ,
                          pTopNode->nRightX, pTopNode->nRightZ, 1);



        pLeftNode->pVariance = pLeftVariance;
        pBottomNode->pVariance = pBottomVariance;
        pRightNode->pVariance = pRightVariance;
        pTopNode->pVariance = pTopVariance;


        TessellateTriTree(pBottomNode, pEM, pError[i]);

        TriTreeNode * pFirstNode = pBottomNode;
        while (pFirstNode->pPre != NULL)
        {
            pFirstNode = pFirstNode->pPre;
        }


        memset(pVerticesUsed, 0, sizeof(effBOOL) * TERRAIN_TILE_PIXEL_SIZE * TERRAIN_TILE_PIXEL_SIZE);

        std::vector<effUINT16> aryIndices;

        TriTreeNode * pPreNode = NULL;
        TriTreeNode * pNode = pFirstNode;
        while ( pNode != NULL )
        {
            effINT nIndex[3];

            nIndex[0] = pNode->nLeftZ * TERRAIN_TILE_PIXEL_SIZE + pNode->nLeftX;
            nIndex[1] = pNode->nApexZ * TERRAIN_TILE_PIXEL_SIZE + pNode->nApexX;
            nIndex[2] = pNode->nRightZ * TERRAIN_TILE_PIXEL_SIZE + pNode->nRightX;

            //add first triangle' three vertex
            if ( pPreNode == NULL )
            {
                for ( effINT j = 0; j < 3; j++ )
                {
                    aryIndices.push_back((effUINT16)nIndex[j]);
                    pVerticesUsed[nIndex[j]] = effTRUE;
                    m_nIndicesNum[i]++;
                }
            }
            else
            {
                effINT nPreIndex[3];
                nPreIndex[0] = pPreNode->nLeftZ * TERRAIN_TILE_PIXEL_SIZE + pPreNode->nLeftX;
                nPreIndex[1] = pPreNode->nApexZ * TERRAIN_TILE_PIXEL_SIZE + pPreNode->nApexX;
                nPreIndex[2] = pPreNode->nRightZ * TERRAIN_TILE_PIXEL_SIZE + pPreNode->nRightX;


                for ( effINT j = 0; j < 3; j++ )
                {

                    if ( nIndex[j] != nPreIndex[0] && nIndex[j] != nPreIndex[1] && nIndex[j] != nPreIndex[2]  )
                    {
                        //from the second triangle, we need to check if we should add a degenerate edge

                        static effINT nSharedEdgeVertexIndex[3][2] = { {1,2}, {0,2}, {0,1} };
                        effINT nSize = (effINT)aryIndices.size();

                        effINT nSharedEdgeVertexIndex0 = nIndex[nSharedEdgeVertexIndex[j][0]];
                        effINT nSharedEdgeVertexIndex1 = nIndex[nSharedEdgeVertexIndex[j][1]];

                        //if the last edge(aryIndices[nSize-1], aryIndices[nSize-2]) in the triangle stripe(aryIndices) is not the shared edge
                        //(nIndex[nSharedEdgeVertexIndex[j][0]], nIndex[nSharedEdgeVertexIndex[j][1]])
                        //so we need add a degenerate edge
                        if ( !(((nSharedEdgeVertexIndex0 == aryIndices[nSize-1]) && (nSharedEdgeVertexIndex1 == aryIndices[nSize-2])) ||
                                ((nSharedEdgeVertexIndex1 == aryIndices[nSize-1]) && (nSharedEdgeVertexIndex0 == aryIndices[nSize-2]))) )
                        {
                            TriTreeNode * pNextNode = pNode->pNext;

                            if ( pNextNode != NULL )
                            {
                                effINT nNextIndex[3];

                                nNextIndex[0] = pNextNode->nLeftZ*TERRAIN_TILE_PIXEL_SIZE + pNextNode->nLeftX;
                                nNextIndex[1] = pNextNode->nApexZ*TERRAIN_TILE_PIXEL_SIZE + pNextNode->nApexX;
                                nNextIndex[2] = pNextNode->nRightZ*TERRAIN_TILE_PIXEL_SIZE + pNextNode->nRightX;

                                effBOOL bVertex0First = effTRUE;
                                for ( effINT k = 0; k < 3; k++ )
                                {
                                    if ( nNextIndex[k] == nSharedEdgeVertexIndex0 )
                                    {
                                        bVertex0First = effFALSE;
                                        break;
                                    }
                                }

                                if ( bVertex0First )
                                {
                                    aryIndices.push_back(nSharedEdgeVertexIndex0);
                                    aryIndices.push_back(nSharedEdgeVertexIndex1);
                                    m_nIndicesNum[i] += 2;
                                }
                                else
                                {
                                    aryIndices.push_back(nSharedEdgeVertexIndex1);
                                    aryIndices.push_back(nSharedEdgeVertexIndex0);
                                    m_nIndicesNum[i] += 2;
                                }
                            }
                            //we don't care the vertex sequence
                            else
                            {
                                aryIndices.push_back(nSharedEdgeVertexIndex0);
                                aryIndices.push_back(nSharedEdgeVertexIndex1);
                                m_nIndicesNum[i] += 2;
                            }
                        }

                        aryIndices.push_back((effUINT16)nIndex[j]);
                        //pVerticesUsed[nIndex[j]] = effTRUE;
                        m_nIndicesNum[i]++;
                    }
                }
            }

            pPreNode = pNode;
            pNode = pNode->pNext;
        }

        m_pIndices[i] = EFFNEW effUINT16[m_nIndicesNum[i]];
        memcpy(m_pIndices[i], &aryIndices[0], sizeof(effUINT16) * m_nIndicesNum[i]);

        pNode = pFirstNode;
        while ( pNode != NULL )
        {
            TriTreeNode * pNext = pNode->pNext;
            SF_DELETE(pNode);
            pNode = pNext;
        }

    }



    effINT * pGeneratedVerticesId = EFFNEW effINT[TERRAIN_TILE_PIXEL_SIZE * TERRAIN_TILE_PIXEL_SIZE];
    memset(pGeneratedVerticesId, -1, sizeof(effINT)*TERRAIN_TILE_PIXEL_SIZE * TERRAIN_TILE_PIXEL_SIZE);
    effINT nGeneratedVerticesNum = 0;

    std::vector<effFLOAT> aryVertices;

    for ( effINT i = 0; i < nLevel; i++ )
    {
        for ( effINT j = 0; j < m_nIndicesNum[i]; j++ )
        {


            effINT nIndex = (effINT)m_pIndices[i][j];

            if ( pGeneratedVerticesId[nIndex] == -1 )
            {
                effINT nX = nIndex % TERRAIN_TILE_PIXEL_SIZE;
                effINT nZ = -nIndex / TERRAIN_TILE_PIXEL_SIZE;
                aryVertices.push_back((effFLOAT)nX);
                aryVertices.push_back(((effFLOAT)pEM[nIndex]) * 0.01f);
                aryVertices.push_back((effFLOAT)nZ);

                m_pIndices[i][j] = (effUINT16)nGeneratedVerticesNum;
                pGeneratedVerticesId[nIndex] = nGeneratedVerticesNum;

                nGeneratedVerticesNum++;
            }
            else
            {
                m_pIndices[i][j] = (effUINT16)pGeneratedVerticesId[nIndex];
            }
        }
        m_nVerticesNum[i] = nGeneratedVerticesNum;
    }

    m_pVertices = EFFNEW effFLOAT[sizeof(effFLOAT) * 3* nGeneratedVerticesNum];
    memcpy(m_pVertices, &aryVertices[0], sizeof(effFLOAT) * 3 * nGeneratedVerticesNum);

    SFT_DELETE(pVerticesUsed);
    SFT_DELETE(pGeneratedVerticesId);

}