Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[MorleyDev]

The standard also provides a few nice guaranteed size and guaranteed minimum size typedefs.

[MadocComadrin]

I've been reading some stuff recently, and to draw the two current topics together (undefined behavior in C++ and A* union solutions), I don't think using unions like that is technically legal C++.

http://stackoverflow.com/questions/15952204/using-char-array-inside-union

[Mego]

The standard also provides a few nice guaranteed size and guaranteed minimum size typedefs.

And those should be used in all cases where the programmer wants to rely on the type having a certain number of bits.

[MagmaMcFry]

The standard also provides a few nice guaranteed size and guaranteed minimum size typedefs.

Well that's useful.

[Skyrunner]

Making similar coordinate values have similar hashes slows things down?

[MagmaMcFry]

Making similar coordinate values have similar hashes slows things down?

If the hash value isn't scrambled again internally by the unordered_map when it gets used to index a bucket, then yes.

[ECrownofFire]

It really depends on the implementation/algorithm of the hash map. Some implementations are actually worse with random keys than sequential ones.

Eeeh... the bitshifting is only guaranteed to work if both of the int32s are actually uint32s.

seriously, use the union, it's safer.

Left bit-shifts work the same for signed and unsigned types.

[Angle]

I'm writing some code where conditions can be described in my JSON Raws, and I'm stuck cause I can't decide which method to use.

Method one works by writing up a small interface, "Condition". Condition would be extended into a few actual classes, which hold the information about a condition, and a method to check if it's been met. For example, there might be a simple StatCondition, which remembers a stat and the numbers it has to be above or below, and there might be a CompositeCondition, which has a couple other conditions that it requires one or both of to be met, etc. When reading the Raws, the program builds a hierarchy of these as described.

Method two works by not parsing the relevant JSON object until it actually needs to check if the conditions are met or not. It'll have to parse it each time it checks, but it involves less programming on my part, and probably less memory usage too.

Or maybe there's another way I haven't thought of, that'll work better? Advise me, internets!

[RulerOfNothing]

It would be better if you could hold off on parsing the JSON object until you need it, but hold onto the relevant data after you've parsed the object. Unless there is something I'm missing which prevents you from doing the second part, but I can't really see it.

[Angle]

That would be more complicated, but I could do it. The main downside is that It might need to parse a bunch of stuff at once, and might lag a little. If it does that in the beginning while loading, then it's not a big deal, but I'd rather avoid it happening in game.

[MagmaMcFry]

I'd recommend parsing the conditions into condition objects immediately and not holding on to any JSON after you finish loading a raw file. It's much easier to write and it's tons faster too.

[Skyrunner]

Parsing is extremely fast. Faster than you'd think, even, assuming the entire JSON is slurped into memory. Because JSON files are larger than the parsed data with no exception, and since loading files is slower than accessing RAM memory, I suggest parsing the data then releasing the JSON at program startup.

I'd recommend parsing the conditions into condition objects immediately and not holding on to any JSON after you finish loading a raw file. It's much easier to write and it's tons faster too.

This is actually my entire post, I noticed.

Unless your JSON file is a couple gigabytes there's no reason not to slurp it c:

[Angle]

I meant parsing the text into JSONObjects, and holding onto those, not parsing the text on the spot, but yes, I'm going ahead and writing the classes now.

[lordnincompoop]

Hey. I've sketched out a program in C++ to build a Markov chain of words and likeliest followups from a text (basic prediction stuff). It compiles fine, but it crashes on startup with an error message stating "deque iterator not dereferencable".

Of the classes below, it doesn't seem to rely on the Tokeniser function but something in the MarkovBuilder or the node class. I can't puzzle it out, though; not only do I have very limited experience with iterators (the code for the FindLikeliest function was mostly copy-pasted from the reference for begin() ) but try as I might, I don't have enough expertise to find the error.

Anyone else see it?

Spoiler: This was compiled using MSVC12 (click to show/hide)

#include <map>
#include <unordered_map>
#include <queue>
#include <string>
#include <fstream>
#include <iostream>

struct MarkovNode {
   MarkovNode();
   std::string FindLikeliest();
   unsigned int totalLinksCount;
   std::map <std::string, unsigned int> linksForward;
};

MarkovNode::MarkovNode() {
   totalLinksCount = 0;
}
std::map <std::string, unsigned int> linksForward;

std::string MarkovNode::FindLikeliest() {
   std::pair <std::string, unsigned int> likeliest;
   if (linksForward.empty() != true) {
      likeliest = *linksForward.begin();
      for ( std::map <std::string, unsigned int>::iterator it = linksForward.begin(); it != linksForward.end(); ++it ) {
         if(it->second > likeliest.second); likeliest = *it;
      }
      return likeliest.first;
   }
}

std::unordered_map <std::string, MarkovNode> MarkovBuilder (std::queue <std::string> tokens) {
   if (tokens.empty() != true) {
      std::string lastWord;
      std::unordered_map <std::string, MarkovNode> markovChain; // New graph

      markovChain.emplace ("START", MarkovNode()); // Start node for empty text

      markovChain.emplace (tokens.front(), MarkovNode()); // Node for first
      markovChain["START"].linksForward.emplace(tokens.front(), 1); // Link to start node

      lastWord = tokens.front();
      while (tokens.empty() == false) {
         tokens.pop(); // Removes first word
         markovChain.emplace (tokens.front(), MarkovNode()); // Node for second
         if ( markovChain[lastWord].linksForward.count(tokens.front()) == 1 ) { // Increments count for link to second word if one exists
            markovChain[lastWord].linksForward[tokens.front()]++;
         } else {
            markovChain[lastWord].linksForward.emplace(tokens.front(), 1); // Creates a new link.
         }
         lastWord = tokens.front(); // Moves on to third.
      }

      return markovChain;
   }
}
   // Chain always starts with a START node.

std::unordered_map <std::string, MarkovNode> MarkovBuilder
      ( std::queue <std::string> tokens, std::unordered_map <std::string, MarkovNode> markovChain) {

   std::string lastWord;

   markovChain.emplace (tokens.front(), MarkovNode()); // Node for first
   if (markovChain["START"].linksForward.count(tokens.front()) == 1 ) {
      markovChain["START"].linksForward[tokens.front()]++;
   } else {
   markovChain["START"].linksForward.emplace(tokens.front(), 1); // Link to start node
   }

   lastWord = tokens.front();
   while (tokens.empty() == false) {
      tokens.pop(); // Removes first word
      markovChain.emplace (tokens.front(), MarkovNode()); // Node for second; if existing, this will simply let it refer to the earlier occurrence.
      if ( markovChain[lastWord].linksForward.count(tokens.front()) == 1 ) { // Increments count for link to second word if one exists
         markovChain[lastWord].linksForward[tokens.front()]++;
      } else {
         markovChain[lastWord].linksForward.emplace(tokens.front(), 1); // Creates a new link.
      }
      lastWord = tokens.front(); // Moves on to third.
   }

   return markovChain;
}

std::queue <std::string> Tokeniser (std::string filename) {
   std::queue <std::string> token;
   std::ifstream file (filename, std::ios::in|std::ios::binary|std::ios::ate);
   if (file.is_open())
   {
      file.seekg(0, std::ios::end);
      unsigned long size = file.tellg();
      char *contents = new char [size];
      file.seekg (0, std::ios::beg);
      file.read (contents, size);
      file.close();
      char* tok = strtok(contents," ");
      while (tok != NULL) {
         token.push(tok);
         tok = strtok(NULL," ");
      }
      delete [] contents;
   }
   return token;
}

int main ()
{
   std::queue <std::string> tokens = Tokeniser ("sample.txt");
   std::unordered_map <std::string, MarkovNode> markovChain = MarkovBuilder(tokens);

   unsigned int outputLengthTokens = 5;

   std::string nextToken;
   std::string temp;

   std::string typicalPhrase;
   nextToken = markovChain["START"].FindLikeliest();
   temp = nextToken;
   typicalPhrase = nextToken;

   for(unsigned short i = 1; i < outputLengthTokens; ++i) {
      nextToken = markovChain[temp].FindLikeliest();
      temp = nextToken;
      typicalPhrase.append(" ");
      typicalPhrase.append(nextToken);
   }

   std::cout << typicalPhrase;
   
   return 0;
}

[ECrownofFire]

Use the debugger and find out where it crashed. MSVC has a fairly good one. It sounds like you might be dereferencing an "end" iterator or an iterator inside an empty container.

On other notes, that code hurts my eyes

You should really be using range-for loops.
MarkovNode constructor is unnecessary and inefficient, you should just use default initialization (totalLinksCount = 0;).
This is incredibly overcomplicated. Just have each node store its own string and a std::list of its children.