Exemplo n.º 1
0
HashTable *HashTableNew(int size) {
   HashTable* table = NULL;
   int i = 0;

   table = MNewPtr(sizeof(HashTable));

   table->size = size;
   table->array = MNewPtr(sizeof(VoidListPtr) * size);

   for(i = 0; i < size; i++) {
      table->array[i] = VLNew();
      DebugError(table->array[i] == NULL, "Failed allocate in HashTableNew");
   }

   return table;
}
Exemplo n.º 2
0
Arquivo: vfbn2.c Projeto: burnmg/vfml
int main(int argc, char *argv[]) {
   int i,j;

   VoidListPtr activeSearches, inactiveSearches, pausedSearches;
   int allDone, changes;

   struct tms starttime;
   struct tms endtime;
   long learnTime;

   long seenTotal, exampleNumber;

   char dataFileName[255];
   FILE *exampleIn;
   ExamplePtr e;

   FILE *netOut;

   /* init the data */
   _InitializeGlobals(argc, argv);

   times(&starttime);

   /* set up the many searches */
   activeSearches = VLNew();
   inactiveSearches = VLNew();
   pausedSearches = VLNew();
   for(i = 0 ; i < BNGetNumNodes(gCurrentNet) ; i++) {
      VLAppend(inactiveSearches, MSNew(gCurrentNet, i));
   }
   _ActivateSearches(activeSearches, inactiveSearches, pausedSearches);

   sprintf(dataFileName, "%s/%s.data", gSourceDirectory, gFileStem);
   if(gStdin) {
      exampleIn = stdin;
   } else {
      exampleIn = fopen(dataFileName, "r");
      DebugError(exampleIn == 0, "Unable to open the data file");
   }

   seenTotal = exampleNumber = 0;
   allDone = 0;

   while(!allDone) {
      e = ExampleRead(exampleIn, gEs);
      if(e != 0) {
         exampleNumber++;
      } else {
         /* if example file is empty reset it.  if stdin, then stop */
         if(gStdin) {
            allDone = 1;
         } else {
            fclose(exampleIn);
            exampleIn = fopen(dataFileName, "r");
            DebugError(exampleIn == 0, "Unable to open the data file");
            e = ExampleRead(exampleIn, gEs);
            exampleNumber = 1;
         }
      }
      seenTotal++;

      changes = 0;
      if(!allDone) {
         /* give the eg+num to each search */
         for(i = 0 ; i < VLLength(activeSearches) ; i++) {
            MSAddExample(VLIndex(activeSearches, i), e, exampleNumber);
         }

         /* HERE maybe add to the deactivated searches to est params */

         /* if chunk time then tell them all to check for winners */
         if(seenTotal % gChunk == 0) {
            DebugMessage(1, 1, 
                  "===== check there are %d active %d inactive =====\n",
                     VLLength(activeSearches), VLLength(inactiveSearches));
            /* see if there are any changes to structure */
            for(i = VLLength(activeSearches) - 1 ; i >= 0 ; i--) {
               gNumCheckPointBoundsUsed += 
                          MSNumActiveAlternatives(VLIndex(activeSearches, i));

               if(MSIsDone(VLIndex(activeSearches, i))) {
                  /* several things could make it done, conflicts eg */
                  MSFree(VLRemove(activeSearches, i));
                  changes = 1;
               } else if(MSCheckForWinner(VLIndex(activeSearches, i))) {
                  changes = 1;
                  /* Go through all the others and check for conflicts */
                  for(j = VLLength(activeSearches) - 1 ; j >= 0 ; j--) { 
                     if(j != i) {
                       MSModelChangedHandleConflicts(
                                           VLIndex(activeSearches, j));
                       /* note this may force a winner or a no-decision */
                     }
                  }

                  if(MSIsDone(VLIndex(activeSearches, i))) {
                     MSFree(VLRemove(activeSearches, i));
                  } else {
                     VLAppend(pausedSearches, VLRemove(activeSearches, i));
                  }
               }
            }

            /* do another pass to remove done and inactive searches */
            for(i = VLLength(activeSearches) - 1 ; i >= 0 ; i--) {
               if(MSIsDone(VLIndex(activeSearches, i))) {
                  changes = 1;
                  /* several things could make it done, conflicts eg */
                  MSFree(VLRemove(activeSearches, i));
               } else if(!MSIsActive(VLIndex(activeSearches, i))) {
                  changes = 1;
                  VLAppend(pausedSearches, VLRemove(activeSearches, i));
               }
            }

            if(changes) {
               _ActivateSearches(activeSearches, inactiveSearches, 
                                                        pausedSearches);
               changes = 0;
            }

            /* if everyone is done then stop */
            if(VLLength(activeSearches) == 0) {
               allDone = 1;
            }

            if(_IsTimeExpired(starttime)) {
               allDone = 1;
               gFinishedByTime = 1;
            }
         }

      } else {
         /* will be allDone if reading from stdin and got no eg */
         /*    or if time expired */
         /* tell every search to call a tie and finish up */

         for(i = 0 ; i < VLLength(activeSearches) ; i++) {
            MSTerminateSearch(VLIndex(activeSearches, i));
         }

         /* NOTE: Ignore the non-active searches, they won't have anything to
                         add to the results and can just quit */
      }

      ExampleFree(e);
   } /* !allDone */

   /* print out final things */
   /* HERE need to get: maybe p0? */
   times(&endtime);
   learnTime = endtime.tms_utime - starttime.tms_utime;
   DebugMessage(1, 1, "done learning...\n");
   DebugMessage(1, 1, "time %.2lfs\n", ((double)learnTime) / 100);

   DebugMessage(1, 1, "Total Samples: %ld\n", seenTotal);

   if(gOutputNet) {
      netOut = fopen(gNetOutput, "w");
      BNWriteBIF(gCurrentNet, netOut);
      fclose(netOut);
   } else {
      BNWriteBIF(gCurrentNet, stdout);
   }

   BNPrintStats(gCurrentNet);

   DebugMessage(1, 1, "   Num decisions %ld by tie %ld by win %ld\n",
                     gNumBoundsUsed, gNumByTie, gNumByWin);
   DebugMessage(1, 1, 
          "   Samples in step min: %ld max: %ld avg: %ld zero# %ld\n",
              gMinSamplesInDecision, gMaxSamplesInDecision,
              gTotalSamplesInDecision / (gNumRemoved + gNumAdded),
                                      gNumZeroSamplesInDecision);
   DebugMessage(1, 1, "   Num removed %ld, Num added %ld\n",
                       gNumRemoved, gNumAdded);
   DebugMessage(1, 1, "   Num used whole DB %ld\n", gNumUsedWholeDB);
   DebugMessage(1, 1, "   Search end by win %ld in tie %ld default %ld\n", 
                     gNumCurrentByWin, gNumCurrentInTie, gNumCurrentByDefault);
   DebugMessage(1, 1, "   Elim by conflict: cycle %ld, parameter %ld\n",
                         gNumByCycleConflict, gNumByParameterConflict);
   DebugMessage(1, 1, "   Elim by parent limit %ld\n", gNumByParentLimit);
   DebugMessage(1, 1, "   Elim by parameter limit %ld\n",
                                           gNumByParameterLimit);
   DebugMessage(1, 1, "   Elim by memory limit %ld\n", gNumByMemoryLimit);
   DebugMessage(1, 1, "   Elim by change limit %ld\n", gNumByChangeLimit);
   DebugMessage(1, 1, "   Num single searches too big for memory %ld\n",
                                        gNumExceededMemory); 
   DebugMessage(1, 1, "   Current effective Delta is %lf\n",
               gNumBoundsUsed * gDelta);
   DebugMessage(1, 1, "   Num in checkpoint %ld adjusted delta %lf\n",
                                          gNumCheckPointBoundsUsed,
                    (gNumBoundsUsed  + gNumCheckPointBoundsUsed) * gDelta);
   DebugMessage(gFinishedByTime, 1, "   ****** Time Expired ******\n");
   DebugMessage(1, 1, "   allocation %ld\n", MGetTotalAllocation());
 
   return 0;     
}
OSErr EditProfilesInit(DialogPtr dialog, VOIDPTR data)
{
    Rect r = GetDialogItemBox(dialog, EPLIST);
    float startdepth;
    CProfilesList *tlist;
    DepthValuesSet dvals;
    long i,n;
    OSErr err = 0;
    short IBMoffset;

    //RegisterPopTable(prefPopTable, 3);
    //RegisterPopUpDialog(EDIT_PROFILES_DLGID, dialog);

    //sharedEPDialogNonPtrFields = GetEPDialogNonPtrFields(sgWindMover);// JLM 11/25/98
    memset(&sgObjects,0,sizeof(sgObjects));// JLM 12/10/98

    {
        DepthValuesSetH dvalsh = sgDepthValuesH;

        sgDepthVals = new CProfilesList(sizeof(DepthValuesSet));
        if(!sgDepthVals)return -1;
        if(sgDepthVals->IList())return -1;
        if(dvalsh)
        {
            // copy list to temp list
            n = _GetHandleSize((Handle)dvalsh)/sizeof(DepthValuesSet);
            for(i=0; i<n; i++)
            {
                dvals=(*dvalsh)[i];
                err=sgDepthVals->AppendItem((Ptr)&dvals);
                if(err)return err;
            }
        }
        else  n=0;

        n++; // Always have blank row at bottom

        err = VLNew(dialog, EPLIST, &r,n, DrawProfilesList, &sgObjects);
        if(err) return err;
    }


    SetDialogItemHandle(dialog,EPFRAMEINPUT,(Handle)FrameEmbossed);
    //SetDialogItemHandle(dialog,EPBUTTONFRAME,(Handle)FrameEmbossed);
    SetDialogItemHandle(dialog,EPLIST,(Handle)ProfilesListUpdate);

    //ShowHideDialogItem(dialog,EPBUTTONFRAME,false);//JLM, hide this frame, we have a different button arrangement

    r = GetDialogItemBox(dialog,EPLIST);
#ifdef IBM
    IBMoffset = r.left;
#else
    IBMoffset = 0;
#endif
    r = GetDialogItemBox(dialog, EPDEPTH_LIST_LABEL);
    DEPTH_COL=(r.left+r.right)/2-IBMoffset;
    r = GetDialogItemBox(dialog, EPU_LIST_LABEL);
    U_COL=(r.left+r.right)/2-IBMoffset;
    r = GetDialogItemBox(dialog, EPV_LIST_LABEL);
    V_COL=(r.left+r.right)/2-IBMoffset;
    r = GetDialogItemBox(dialog, EPW_LIST_LABEL);
    W_COL=(r.left+r.right)/2-IBMoffset;
    r = GetDialogItemBox(dialog, EPTEMP_LIST_LABEL);
    TEMP_COL=(r.left+r.right)/2-IBMoffset;
    r = GetDialogItemBox(dialog, EPSAL_LIST_LABEL);
    SAL_COL=(r.left+r.right)/2-IBMoffset;

    // might want to use values of first set if there are any
    Float2EditText(dialog, EPINCREMENT,sIncrementInMeters, 0);
    Float2EditText(dialog, EPDEPTH,0.0, 0);
    Float2EditText(dialog, EPU,0.0, 0);
    Float2EditText(dialog, EPV,0.0, 0);
    //Float2EditText(dialog, EPW,0.0, 0);
    Float2EditText(dialog, EPTEMP,0.0, 0);
    Float2EditText(dialog, EPSAL,0.0, 0);

    //Float2EditText(dialog, EPDXDY,sCellLength, 0);
    //Float2EditText(dialog, EPNUMCELLS,sNumCells, 0);
    //SetPopSelection (dialog, EPSPEEDPOPUP, sgSpeedUnits);
    //MyDisplayTime(dialog,EPMONTHSPOPUP,sgStartTime);

    //////////

    SetDialogItemHandle(dialog, EPHILITEDDEFAULT, (Handle)FrameDefault);

    ShowHideDialogItem(dialog,EPHILITEDDEFAULT,false);//JLM, hide this item, this dialog has no default

    UpdateDisplayWithCurSelection(dialog);

    MySelectDialogItemText(dialog, EPDEPTH, 0, 100);//JLM
    return 0;
}
Exemplo n.º 4
0
Arquivo: vfbn2.c Projeto: burnmg/vfml
int oldMain(int argc, char *argv[]) {
   FILE *exampleIn;
   FILE *netOut;
   ExamplePtr e;

   while(!allDone) {
      searchStep++;
      DebugMessage(1, 2, "============== Search step: %d ==============\n",
             searchStep);
      DebugMessage(1, 2, "  Total samples: %ld Last round: %ld\n",
                       seenTotal, seenRound);
      DebugMessage(1, 2, " allocation before choices %ld\n", 
                                               MGetTotalAllocation());

      DebugMessage(1, 2, "   best with score %f:\n", _ScoreBN(bn));
      if(DebugGetMessageLevel() >= 2) {
         BNPrintStats(bn);
      }

      if(DebugGetMessageLevel() >= 3) {
         BNWriteBIF(bn, DebugGetTarget());
      }

      netChoices = VLNew();

      _GetOneStepChoicesForBN(bn, netChoices);

      DebugMessage(1, 2, " allocation after choices %ld there are %d\n", 
                         MGetTotalAllocation(), VLLength(netChoices));



      seenRound = 0;
      stepDone = 0;
      e = ExampleRead(exampleIn, es);
      while(!stepDone && e != 0) {
         seenTotal++;
         seenRound++;
         /* put the eg in every net choice */
         _OptimizedAddSample(bn, netChoices, e);

         /* if not batch and have seen chunk then check for winner */
         if(!gDoBatch && (seenRound % gChunk == 0)) {
            _CompareNetsBoundFreeLoosers(bn, netChoices);
            if(VLLength(netChoices) == 1) {
               stepDone = 1;
            } else {
               DebugMessage(1, 2, 
                    "   done with check seen in round %ld, %d left\n", 
                        seenRound, VLLength(netChoices));

            }
         }

         ExampleFree(e);
         e = ExampleRead(exampleIn, es);
      } /* !stepDone && e != 0 */

      ILAppend(samplesPerRound, seenRound);

      /* if examples ran out before bound kicked in pick a winner */
      if(VLLength(netChoices) > 1) {
         DebugMessage(!gDoBatch, 1,
         "Ran out of data before finding winner, using current best of the remaining %d.\n", VLLength(netChoices));
         _CompareNetsFreeLoosers(bn, netChoices);
      }

      /* if the winner is the current one then we are all done */
      if(BNStructureEqual(bn, (BeliefNet)VLIndex(netChoices, 0))) {
         /* make sure to free all loosing choices and the netChoices list */
         allDone = 1;
      } else if(gMaxSearchSteps != -1 && searchStep >= gMaxSearchSteps) {
         DebugMessage(1, 1, "Stopped because of search step limit\n");
         allDone = 1;
      }

      /* copy all the CPTs that are only in bn into the new winner */
       /* only really needed for final output but I do it for debugging too */
      _UpdateCPTsForFrom((BeliefNet)VLIndex(netChoices, 0), bn);


      if(gOnlyEstimateParameters) {
         allDone = 1;
      }

      /* now check all previous winners */
      /* if we detect a cycle, pick the best that happens
            in the period of the cycle */
      if(!allDone) {
         for(i = 0 ; i < VLLength(previousWinners) ; i++) {
            if(BNStructureEqual(bn, (BeliefNet)VLIndex(previousWinners, i))) {
               allDone = 1;
            }

            if(allDone) {
               if(_ScoreBN(bn) < 
                       _ScoreBN((BeliefNet)VLIndex(previousWinners, i))) {
                  bn = VLIndex(previousWinners, i);
               }
            }
         }
      }


      if(!allDone) {
         VLAppend(previousWinners, BNClone(bn));

         _FreeUserData(bn);
         BNFree(bn);
         bn = (BeliefNet)VLRemove(netChoices, 0);
         _FreeUserData(bn);
         VLFree(netChoices);
      }

      DebugMessage(1, 2, "Current effective Delta is %lf\n", 
               gNumBoundsUsed * gDelta);
      DebugMessage(1, 2, "Current observed p0 is %lf\n", 
               gObservedP0);
      DebugMessage(1, 2, " allocation after all free %ld\n", 
                                           MGetTotalAllocation());

      /* reset file if not in stdin mode */
      if(!gStdin) {
         fclose(exampleIn);
         exampleIn = fopen(fileName, "r");
         DebugError(exampleIn == 0, "Unable to open the data file");
      }
   } /* while !allDone */



   DebugMessage(1, 1, "Total Samples: %ld\n", seenTotal);
   if(DebugGetMessageLevel() >= 1) {
      DebugMessage(1, 1, "Samples per round:\n");
      for(i = 0 ; i < ILLength(samplesPerRound) ; i++) {
         DebugMessage(1, 1, "%d %d\n", i + 1, ILIndex(samplesPerRound, i));
      }
   }

   allocation = MGetTotalAllocation();

   printf("Final score: %f\n", _ScoreBN(bn));
   printf("Final net:\n");
   BNWriteBIF(bn, stdout);

   if(gOutputNet) {
      netOut = fopen(gNetOutput, "w");
      BNWriteBIF(bn, netOut);
      fclose(netOut);
   }

   BNFree(bn);
   ExampleSpecFree(es);
   DebugMessage(1, 1, "   allocation %ld\n", MGetTotalAllocation());
   return 0;
}