static void names_init(t_env *env)
{
struct rlimit rlp;
int j;
X(-1, getrlimit(RLIMIT_NOFILE, &rlp), "getrlimit");
j = rlp.rlim_cur;
env->max_teams = j;
env->tnames = (char **)XV(NULL, malloc(sizeof(char *) * j), "names_init");
bzero(env->tnames, sizeof(char *) * j);
}
int getteams(t_env *e, char *av)
{
t_team *t;
t = (t_team*)XV(NULL, malloc(sizeof(t_team)), "malloc");
t->nb_player = 0;
t->level8 = 0;
t->name = av;
t->next = e->team;
e->team = t;
return (EX_SUCCESS);
}
void init_env(t_env *e)
{
int i;
struct rlimit rlp;
X(-1, getrlimit(RLIMIT_NOFILE, &rlp), "getrlimit");
e->maxfd = 1000;
e->fds = (t_fd*)XV(NULL, malloc(sizeof(*e->fds) * e->maxfd), "malloc");
i = 0;
while (i < e->maxfd)
{
clean_fd(&e->fds[i]);
i++;
}
}
void srv_create(t_env *e, int port)
{
int s;
struct sockaddr_in sin;
struct protoent *pe;
pe = (struct protoent*)XV(NULL, getprotobyname("tcp"), "getprotobyname");
s = X(-1, socket(PF_INET, SOCK_STREAM, pe->p_proto), "socket");
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
X(-1, bind(s, (struct sockaddr*)&sin, sizeof(sin)), "bind");
X(-1, listen(s, 42), "listen");
e->fds[s].type = FD_SERV;
e->fds[s].fct_read = srv_accept;
}
void map_init(void)
{
int size;
int i;
int j;
size = g_env->mapw * g_env->maph;
g_env->sq = (t_square *)XV(NULL,
malloc(sizeof(t_square) * (size + 1)), "map");
bzero(g_env->sq, sizeof(t_square) * (size + 1));
i = -1;
while (++i < size)
{
j = -1;
while (++j < CASE_MAX_ITEMS - 1)
g_env->sq[i].grid[j] = j;
rand_itm_pos(&g_env->sq[i]);
g_env->sq[i].tile = rand() % 8;
}
}
static void npcs_init(t_env *env)
{
env->npc = (t_npc *)XV(NULL, malloc(sizeof(t_npc) * NPCS_MAX), "mpcs_init");
bzero(env->npc, sizeof(t_npc) * NPCS_MAX);
}
void XVertexBufferD3D::Draw( float x, float y )
{
D3DXMATRIX mWorld;
LPDIRECT3DDEVICE9 pd3dDevice = GRAPHICS_D3D->GetDevice();
D3DXMatrixTranslation( &mWorld, x, y, 0 );
pd3dDevice->SetTransform( D3DTS_WORLD, &mWorld );
HRESULT hr;
XV( XE::s_pEffect->SetMatrix( "mViewProj", &XE::s_mViewProj ) );
XV( XE::s_pEffect->SetMatrix( "mWorld", &mWorld ) );
XV( XE::s_pEffect->SetFloat( "fOpacity", 1.0f ) );
XV( XE::s_pEffect->SetFloat( "col_r", 1.0f ) );
XV( XE::s_pEffect->SetFloat( "col_g", 1.0f ) );
XV( XE::s_pEffect->SetFloat( "col_b", 1.0f ) );
// draw core
XBREAK( m_pd3dVB == NULL );
XV( XE::s_pEffect->SetTechnique( "RenderSprite" ) );
UINT iPass, cPasses;
XV( XE::s_pEffect->Begin( &cPasses, 0 ) );
for( iPass = 0; iPass < cPasses; iPass++ )
{
XV( XE::s_pEffect->BeginPass( iPass ) );
pd3dDevice->SetStreamSource( 0, m_pd3dVB, 0, sizeof(XSURFACE_VERTEX) );
pd3dDevice->SetFVF( D3DFVF_XSURFACE_VERTEX );
pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, m_nNumRect * 2 );
XV( XE::s_pEffect->EndPass() );
}
XV( XE::s_pEffect->End() );
m_nNumRect = 0;
}
/// estimate number of communities using AGM
int TAGMUtil::FindComsByAGM(const PUNGraph& Graph, const int InitComs, const int MaxIter, const int RndSeed, const double RegGap, const double PNoCom, const TStr PltFPrx) {
TRnd Rnd(RndSeed);
int LambdaIter = 100;
if (Graph->GetNodes() < 200) {
LambdaIter = 1;
}
if (Graph->GetNodes() < 200 && Graph->GetEdges() > 2000) {
LambdaIter = 100;
}
//Find coms with large C
TAGMFit AGMFitM(Graph, InitComs, RndSeed);
if (PNoCom > 0.0) {
AGMFitM.SetPNoCom(PNoCom);
}
AGMFitM.RunMCMC(MaxIter, LambdaIter, "");
int TE = Graph->GetEdges();
TFltV RegV;
RegV.Add(0.3 * TE);
for (int r = 0; r < 25; r++) {
RegV.Add(RegV.Last() * RegGap);
}
TFltPrV RegComsV, RegLV, RegBICV;
TFltV LV, BICV;
//record likelihood and number of communities with nonzero P_c
for (int r = 0; r < RegV.Len(); r++) {
double RegCoef = RegV[r];
AGMFitM.SetRegCoef(RegCoef);
AGMFitM.MLEGradAscentGivenCAG(0.01, 1000);
AGMFitM.SetRegCoef(0.0);
TVec<TIntV> EstCmtyVV;
AGMFitM.GetCmtyVV(EstCmtyVV, 0.99);
int NumLowQ = EstCmtyVV.Len();
RegComsV.Add(TFltPr(RegCoef, (double) NumLowQ));
if (EstCmtyVV.Len() > 0) {
TAGMFit AFTemp(Graph, EstCmtyVV, Rnd);
AFTemp.MLEGradAscentGivenCAG(0.001, 1000);
double CurL = AFTemp.Likelihood();
LV.Add(CurL);
BICV.Add(-2.0 * CurL + (double) EstCmtyVV.Len() * log((double) Graph->GetNodes() * (Graph->GetNodes() - 1) / 2.0));
}
else {
break;
}
}
// if likelihood does not exist or does not change at all, report the smallest number of communities or 2
if (LV.Len() == 0) {
return 2;
}
else if (LV[0] == LV.Last()) {
return (int) TMath::Mx<TFlt>(2.0, RegComsV[LV.Len() - 1].Val2);
}
//normalize likelihood and BIC to 0~100
int MaxL = 100;
{
TFltV& ValueV = LV;
TFltPrV& RegValueV = RegLV;
double MinValue = TFlt::Mx, MaxValue = TFlt::Mn;
for (int l = 0; l < ValueV.Len(); l++) {
if (ValueV[l] < MinValue) {
MinValue = ValueV[l];
}
if (ValueV[l] > MaxValue) {
MaxValue = ValueV[l];
}
}
while (ValueV.Len() < RegV.Len()) {
ValueV.Add(MinValue);
}
double RangeVal = MaxValue - MinValue;
for (int l = 0; l < ValueV.Len(); l++) {
RegValueV.Add(TFltPr(RegV[l], double(MaxL) * (ValueV[l] - MinValue) / RangeVal));
}
}
{
TFltV& ValueV = BICV;
TFltPrV& RegValueV = RegBICV;
double MinValue = TFlt::Mx, MaxValue = TFlt::Mn;
for (int l = 0; l < ValueV.Len(); l++) {
if (ValueV[l] < MinValue) {
MinValue = ValueV[l];
}
if (ValueV[l] > MaxValue) {
MaxValue = ValueV[l];
}
}
while (ValueV.Len() < RegV.Len()) {
ValueV.Add(MaxValue);
}
double RangeVal = MaxValue - MinValue;
for (int l = 0; l < ValueV.Len(); l++) {
RegValueV.Add(TFltPr(RegV[l], double(MaxL) * (ValueV[l] - MinValue) / RangeVal));
}
}
//fit logistic regression to normalized likelihood.
TVec<TFltV> XV(RegLV.Len());
TFltV YV (RegLV.Len());
for (int l = 0; l < RegLV.Len(); l++) {
XV[l] = TFltV::GetV(log(RegLV[l].Val1));
YV[l] = RegLV[l].Val2 / (double) MaxL;
}
TFltPrV LRVScaled, LRV;
TLogRegFit LRFit;
PLogRegPredict LRMd = LRFit.CalcLogRegNewton(XV, YV, PltFPrx);
for (int l = 0; l < RegLV.Len(); l++) {
LRV.Add(TFltPr(RegV[l], LRMd->GetCfy(XV[l])));
LRVScaled.Add(TFltPr(RegV[l], double(MaxL) * LRV.Last().Val2));
}
//estimate # communities from fitted logistic regression
int NumComs = 0, IdxRegDrop = 0;
double LRThres = 1.1, RegDrop; // 1 / (1 + exp(1.1)) = 0.25
double LeftReg = 0.0, RightReg = 0.0;
TFltV Theta;
LRMd->GetTheta(Theta);
RegDrop = (- Theta[1] - LRThres) / Theta[0];
if (RegDrop <= XV[0][0]) {
NumComs = (int) RegComsV[0].Val2;
}
else if (RegDrop >= XV.Last()[0]) {
NumComs = (int) RegComsV.Last().Val2;
}
else { //interpolate for RegDrop
for (int i = 0; i < XV.Len(); i++) {
if (XV[i][0] > RegDrop) {
IdxRegDrop = i;
break;
}
}
if (IdxRegDrop == 0) {
printf("Error!! RegDrop:%f, Theta[0]:%f, Theta[1]:%f\n", RegDrop, Theta[0].Val, Theta[1].Val);
for (int l = 0; l < RegLV.Len(); l++) {
printf("X[%d]:%f, Y[%d]:%f\n", l, XV[l][0].Val, l, YV[l].Val);
}
}
IAssert(IdxRegDrop > 0);
LeftReg = RegDrop - XV[IdxRegDrop - 1][0];
RightReg = XV[IdxRegDrop][0] - RegDrop;
NumComs = (int) TMath::Round( (RightReg * RegComsV[IdxRegDrop - 1].Val2 + LeftReg * RegComsV[IdxRegDrop].Val2) / (LeftReg + RightReg));
}
//printf("Interpolation coeff: %f, %f, index at drop:%d (%f), Left-Right Vals: %f, %f\n", LeftReg, RightReg, IdxRegDrop, RegDrop, RegComsV[IdxRegDrop - 1].Val2, RegComsV[IdxRegDrop].Val2);
printf("Num Coms:%d\n", NumComs);
if (NumComs < 2) {
NumComs = 2;
}
if (PltFPrx.Len() > 0) {
TStr PlotTitle = TStr::Fmt("N:%d, E:%d ", Graph->GetNodes(), TE);
TGnuPlot GPC(PltFPrx + ".l");
GPC.AddPlot(RegComsV, gpwLinesPoints, "C");
GPC.AddPlot(RegLV, gpwLinesPoints, "likelihood");
GPC.AddPlot(RegBICV, gpwLinesPoints, "BIC");
GPC.AddPlot(LRVScaled, gpwLinesPoints, "Sigmoid (scaled)");
GPC.SetScale(gpsLog10X);
GPC.SetTitle(PlotTitle);
GPC.SavePng(PltFPrx + ".l.png");
}
return NumComs;
}
