Print

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

[Mego]

I haven't tested it due to having written it up in about 5 minutes and not having time for testing, but this C++ code *should* work for base conversion, if you want to try to use it as a reference.

Spoiler (click to show/hide)

Code: [Select]

#include <string>
#include <cmath>
#include <sstream>
#include <cstdlib>

using namespace std;

string itostr(int i) {
stringstream ss("");
ss << i;
return ss.str();
}

string itodig(int i) {
if(i < 10) return itostr(i);
else if(i <= 36) return string('A'+(i-10));
else throw "Error - maximum base supported is 36";
}

template<int BASEFROM> string toDec(string num) {
if(num.find(".") != num.end()) throw "Error - only integers are supported for base changing."
int res = 0;
int p = 0;
for(auto it = num.rbegin(); it != num.rend(); it++, p++) {
int digit = *it - 0x31;
res += digit*pow(BASEFROM, p);
}
return itostr(res);
}

template<int BASEFROM, int BASETO> string toBase(string num) {
if(num.find(".") != num.end()) throw "Error - only integers are supported for base changing."
if(BASEFROM != 10) num = toDec<BASEFROM>(num);

int num_int = atoi(num.c_str());
int maxp = int(log10(num_int));
string res = "";

for(int i = maxp; i >= 0; i--) {
int c = num_int/pow(BASETO, i);
res += itodig(c);
num_int -= c*pow(BASETO, i);
}

return res;
}


template<int BASETO> string toBase(int num) {
return toBase<10, BASETO>(itostr(num));
}


[MagmaMcFry]

Pseudocode:

Code: [Select]

string numToBaseStr (int baseTo, int num) {
    if (num < baseTo) return toDigit(num);
    lastDigit = num % baseTo;
    return numToBaseStr(baseTo, num/baseTo).append(toDigit(lastDigit));
}

num BaseStrToNum (int baseFrom, string numStr) {
    if (numStr.length() = 1) return fromDigit(numStr);
    lastDigit = fromDigit(numStr.lastChar());
    restOfNum = numStr.withoutLastChar();
    return baseFrom * baseStrToNum(baseFrom, restOfNum) + lastDigit;
}


[Telgin]

Nope. I have absolutely no clue how a pointer goes from non-NULL to NULL, just from being passed to a function. After the function call, it returned to its normal, non-NULL value.

Sounds like variable shadowing from a global or something to me.

[Mego]

Nope. I have absolutely no clue how a pointer goes from non-NULL to NULL, just from being passed to a function. After the function call, it returned to its normal, non-NULL value.

Sounds like variable shadowing from a global or something to me.

This project had absolutely 0 globals. Everything was passed around via function parameters.

[Nadaka]

Nope. I have absolutely no clue how a pointer goes from non-NULL to NULL, just from being passed to a function. After the function call, it returned to its normal, non-NULL value.

Sounds like variable shadowing from a global or something to me.

This project had absolutely 0 globals. Everything was passed around via function parameters.

If it isn't a case of an overloaded name, I would guess that something is stomping on the pointer after a copy has been pushed onto the stack for the function call. Could be a write outside the range of an array or a pointer that gets pointed to the wrong place.

[Skyrunner]

The base converter is done!

What it does: Accepts a string*, an int that represents the base the string is in, an int that represents the base the string should be changed to. The string is changed.

Internally, there is one quirky thing I had to work around: when I input 4.0625, it recognized it as 4.06249999991 or something. Just 0.0625 goes to 0.0625. I did this:

Spoiler (click to show/hide)

  for (it = numberstring->begin();it < numberstring->end();it++)
    {
    if (*it == '.') //if decimal point, skip
      {
      }
    else //else,
      {
      if (decimalplace >= 0)
        number = number + pow((double)From,(int)decimalplace) * *it; // add the base^decimal times the number to number.
      if (decimalplace < 0)
        fpart_number = fpart_number  + pow((double)From,(int)decimalplace) * *it; //Add differently and combine later because precision.

      decimalplace--;
      }
    }

//Somehow round this stuff.......
  number = number + fpart_number;
  return number;

Split the number I use to store the base10 representation of the input string into intpart and fpart, then add them together at the end. Works good.

The reason I posted the source up there is because I want to know what I could do to optimize that code, or better ways to do stuff.

[Mego]

I'm just going to jot down things as I see them.

1. Am I blind, or does CheckString not actually modify stopfunction? Also, why not just let the exception fall through CheckString to Convert?

2. Your error messages should probably be going to cerr and not cout.

3. Why are you using pointers for all your strings? References seem like they would be the more logical choice.

4. You could probably get rid of all the boolean flags with some nifty exception throwing. For example, in your catch blocks, you could add "else throw e" at the end to make the exception fall through.

5. Using brackets to enclose an if-statement inside an else-statement makes code difficult to read in my opinion. "else if(cond) { expr }" is just as valid as "else { if(cond) { expr } }". In addition, nesting those else's inside each other is not really necessary. Execution will go through all of the if- and else-if-statements until the condition matches, it finds an else without an if, or it runs out of statements to check. You can just make a long line of them without nesting and have the same result.

6. A quick way to get rid of weird floating-point arithmetic stuff like representing 4.0625 as 4.06249999... is to format the output to use the same number of decimal (or whatever base you're using) places as the input. It also gives you the bonus of using significant figures, which scientists will love. Also, string formatting is an important skill to learn. There's a lot of different ways to do this specific type, so experiment.

[kaijyuu]

Does anyone here have experience embedding python into a c++ application? If so, can I ask you about a million questions?

[Nadaka]

Well. I spent a few hours today working on MNML again.

Changes: changed the attributename/value separator to | because ; is common and could cause annoying escaping issues for a lot of data (particularly code).

Added strings that do not require most reserved characters to be escaped and also are capable of containing whitespace as data.

rewrote the grammar.

wrote a partial (and extremely hackish) bit of c# capable of creating a mnml string. It would create a  valid mnml string from an object structure if I had the validation of attributeNames, Strings and Words in the objects. I will do that, and eventually make a "pretty printer". as well as a reflection library capable of putting arbitrary c# data objects into mnml form.

MNML

Spoiler: Preface: (click to show/hide)

What is bad about XML:
1: verbosity. each element name is repeated twice, and each of those names is enclosed in its own set of braces.
2: whitespace. xml has fiddly rules for what white space is and is not important, and there are inconsistent implementations in the interpretation of this (thank you microsoft).
3: validity. An entire document must be well formed or discarded entirely. Combine this with the single root element requirement and you have a format unsuitable for streaming data sources.
4: There is more, but screw it for the moment.

What is bad about json:
json has difficulty serializing certain types of objects. In javascript all objects are arrays and all arrays are objects. JSON notation has difficulty dealing with this because it does not allow setting named attributes on arrays, nor does it allow putting values into an object as if it was an array, even though both are possible and indeed frequent in javascript.

Spoiler: Introduction: (click to show/hide)

M    Model-driven
N    Non-xml
M    Markup
L    Language


The actual definition of this acronym is subject to change. The goal of MNML is to create a simple, efficient but effective language to replace the use of XML and/or JSON as a data transport and storage specification in web and other software development. I will use every day English to describe the language explicitly as well as provide a formal grammar.

Spoiler: Overview: (click to show/hide)

this section provides an overview of the structure and format of MNML. The MNML language consists of collections, attributes, values, strings, words, whitespace and comments. Collections strings and words are collectively referred to as elements. Collections and attributes are structured data, they can contain child elements. String and words are unstructured, they do not contain child elements. A MNML document minimally consists of an implied root collection, its attributes (if any) and its child elements (if any). The implied root container allows most conventional text documents to be valid MNML code if they do not contain MNML reserved characters.

A collection is a container structure that can contain 0 or more other elements. When writing MNML, a collection is enclosed by square brackets"[]". Inside that enclosure are the attributes and member elements of the collection. An element within a collection is a child of the collection. The collection containing an element or attribute is called the elements or attributes parent. The ancestors of an element or attribute are its parent and all of the ancestors of its parent including the root collection.

An attribute is a named property of a collection that may or may not have a value associated with it. A collection may only have a single instance of any given attribute. When writing MNML, an attribute always begins with an at "@" character followed by any number of alphanumeric characters. Attributes are always located before any child elements.

A value is an element associated with an attribute of a collection. When writing MNML, a value is separated from its attribute by a vertical bar "|".

NOTE: THE SEPERATOR HAS BEEN CHANGED TO FROM SEMI-COLON BECAUSE SEMI-COLONS ARE RELATIVELY COMMON IN BOTH STANDARD TEXT AND PROGRAMMING LANGUAGES.

A word is a basic token in the MNML language with arbitrary meaning. A word consists of any number of consecutive printable non-whitespace characters. A word can include MNML reserved characters by using an escape sequence. A valid MNML document may consist only of words if desired, this means that text documents are valid MNML documents if they do not contain reserved characters.

A string is another basis token in the MNML language with arbitrary meaning. A string consists of any number of consecutive printable characters enclosed within quotes """". Inside a string whitespace is part of the data and the only necessary escape sequences within a string are for the escape character "\" and the quote """, however the other escape sequences are valid.

Whitespace consists of the space, horizontal tab, new line characters and any other unicode whitespace character. Presence of whitespace is used to separate words from other words and from attributes and values. Whitespace is not required to seperate attributes, collections, strings or values from other attributes, collections, strings or values nor is whitespace requited to seperate collections or strings from words. The type, amount and arrangement of whitespace used outside a string has no bearing on the meaning of a MNML document at all.

Comments are for documenting the markup used with MNML. When writing MNML, a comment is enclosed by parenthesis "()".

Reserved characters for MNML are '@', '|', '(', ')', '[', ']', '"' and '\'. These can be escaped by using the and '\' character. Other escape sequences include space '\s', tab '\t', new line '\n' and collapse whitespace '\c' as well as unicode character representation '\U0000' where 0000 is the codepoint of a unicode character. These escape sequences produce characters that may be part of words or strings. The purpose of the '\c' escape sequence is to allow words to be separated by whitespace in the document and parsed separately, even if they would normally be displayed together. For instance this may be used to separate punctuation from the words of a sentence.

Spoiler: Example MNML compliant document: (click to show/hide)

@title;[@huh?|what? This is the title of this document.]
@some;stuff
This is some content of the document. (this is a comment) [this is some more content and is the 8th element in the root element.] [@foo This has/is a foo.] [@bar;baz This things bar is baz.] \n \( \c this is not a comment but is on a new line. The parenthesis are separate words, but should have no visible whitespace displayed. \c \) [this element has 5 words.] "              This element is a string with a lot of extra whitespace and some characters that would otherwise have to be escaped []@()|                 " "
This string has 2 \"new line\" characters in it.\n the first is normal, the second is escaped. "

Spoiler: Formal Grammar: (click to show/hide)

Note: The '_' character is being used as a seperator to indicate that some form of whitespace must be present.
Note: The '-' character is being used as a seperator to indicate that no form of whitespace may present.
Note: The word epsilon is being used in place of the traditional epsilon character.
Note: There may be some reording of rules and epsilon optimizations, or minor errors.
Note: this grammar assumes that comments are stripped out before processing.
document -> collectionContents

collectionContents -> attribute attributes attributedElements | elements

attributes ->attribute attributes | epsilon

attribute -> @-attributeName value

attributeName -> alphaNumericCharacter-alphaNumericCharacters

value -> | element | epsilon

alphaNumericCharacters -> alphaNumericCharacter-alphaNumericCharacters | epsilon

attributedElements -> collection elements | string elements | _ word elements | epsilon

collection -> [ collectionContents ]

string -> "-stringContents-"

stringContents -> escapedCharacter-stringContents | nonEscapeNonQuoteCharacter-stringContents | epsilon

escapedCharacter -> \-sequence

nonEscapeNonQuoteCharacter -> [ALL CHARACTERS THAT ARE NOT \ OR "]

sequence -> reservedCharacter | s | t | n | c | u-codePoint

reservedCharacter ->  [ | ] | ( | ) | \ | @ | | | "

codePoint -> digit-digit-digit-digit

digit -> 0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9

word -> character-characters

character -> escapedCharacter | nonWhitespaceNonReservedCharacter

characters -> character-characters | epsilon

nonWhitespaceNonReservedCharacter -> [ALL CHARACTERS THAT ARE NOT IN reservedCharacter OR ARE NOT WHITESPACE]

alphaNumericCharacter -> [a-zA-Z0-9 AND UNICODE CHARACTERS OF TYPE LETTER]

elements ->  element elements | epsilon

element -> collection | string | word

whiteSpace -> [ALL CHARACTERS THAT ARE WHITESPACE] | comment

comment -> (-nonClosePerenCharacters-)

nonClosePerenCharacters -> nonClosePerenCharacter nonClosePerenCharacters | epsilon

nonClosePerenCharacter -> [ALL CHARACTERS THAT ARE NOT )]

javascript implementation:
pending...

java implementation:
pending...

Spoiler: c# implementation in progress (click to show/hide)

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace us.nadaka.mnml
{
    public class simpleMnmlReader
    {
    }

    public class simpleMnmlWriter
    {
        public static void buildDocument(StringBuilder builder, MnmlCollection impliedRoot)
        {
            buildCollectionContents(builder, impliedRoot);
        }

        private static void buildCollectionContents(StringBuilder builder, MnmlCollection collection)
        {
            bool hasAttributes = (collection.AttributeCount > 0);
            bool hasChildren = (collection.ChildCount > 0);
            bool lastElementWasWord = false;
            if (hasAttributes)
            {
                foreach (string name in collection.AttributeList)
                {
                    builder.Append("@");
                    builder.Append(name);
                    MnmlElement value;
                    if (collection.tryGetAttribute(name, out value))
                    {
                        if (value != null)
                        {
                            builder.Append("|");
                            lastElementWasWord = buildElement(builder, value, false);
                        }
                    }
                }
                if (hasChildren)
                {
                    builder.Append(" ");
                }
            }
            if (hasChildren)
            {
                foreach (MnmlElement element in collection.Children)
                {
                    lastElementWasWord = buildElement(builder, element, lastElementWasWord);
                }
            }
        }

        private static bool buildElement(StringBuilder builder, MnmlElement value, bool spaceIfWord)
        {
            bool isAWord = false;
            MnmlCollection mCollection = value as MnmlCollection;
            if (mCollection != null)
            {
                builder.Append("[");
                buildCollectionContents(builder, mCollection);
                builder.Append("]");
            }
            else
            {
                MnmlString mString = value as MnmlString;
                if (mString != null)
                {
                    builder.Append("\"");
                    builder.Append(mString.Value);
                    builder.Append("\"");
                }
                else
                {
                    MnmlWord mWord = value as MnmlWord;
                    if (mWord != null)
                    {
                        if (spaceIfWord)
                        {
                            builder.Append(" ");
                        }
                        builder.Append(mWord.Value);
                        isAWord = true;
                    }
                }
            }
            return isAWord;
        }
    }

    public class MnmlCollection : MnmlElement
    {
        private Hashtable _attributes = new Hashtable();
        private List<MnmlElement> _children = new List<MnmlElement>();

        public int AttributeCount
        {
            get { return _attributes.Count; }
        }

        public List<string> AttributeList
        {
            get { return new List<string>(_attributes.Keys.Cast<string>()); }
        }

        public void removeAttribute(string name)
        {
            _attributes.Remove(name);
        }

        public void setAttribute(string name, MnmlElement value)
        {
            if (validateName(name))
            {
                _attributes[name] = value;
            }
        }

        private bool validateName(string name)
        {
            bool answer = true;
            throw new NotImplementedException();
            return answer;
           
        }

        public bool tryGetAttribute(string name, out MnmlElement value)
        {
            if (_attributes.ContainsKey(name))
            {
                value = (MnmlElement)_attributes[name];
                return true;
            }
            else
            {
                value = null;
                return false;
            }
        }


        public int ChildCount
        {
            get { return _children.Count; }
        }

        public List<MnmlElement> Children
        {
            get { return _children; }
        }
    }

    public class MnmlWord : MnmlElement
    {
        private string _value;

        private MnmlWord() { }

        public MnmlWord(string value)
        {
            Value = value;
        }

        public string Value {
            get {return _value; }
            set
            {
                if (validate(value))
                {
                    _value = value;
                }
            }
        }

        public static bool validate(string value)
        {
            bool answer = true;
            throw new NotImplementedException();
            return answer;
        }
    }



    public class MnmlString : MnmlElement
    {
        private string _value;

        private MnmlString() { }

        public MnmlString(string value)
        {
            Value = value;
        }

        public string Value {
            get {return _value; }
            set
            {
                if (validate(value))
                {
                    _value = value;
                }
            }
        }

        public static bool validate(string value)
        {
            bool answer = true;
            throw new NotImplementedException();
            return answer;
        }
    }

    public class MnmlElement
    {
    }
}

[MorleyDev]

So I finally got my "Zander" engine working with my experiments for playing around with concurrency. It works as follows:

At the lowest level you have tasks and a thread pool. The thread pool takes in tasks and executes them on one of n threads.
Tasks can have children, nexts and shared nexts.
A child is pushed onto the thread pool when the task is finished executing.
A next is pushed onto the thread pool when the task, and all of the tasks children, and all of the nexts of the tasks children, and so-on down the graph, are finished executing.
A shared next is a next which has to wait for multiple tasks to fulfil the above conditions before being enqueued.

This lets you build up huge, dynamic graphs of program flow without caring about how many threads you have, the system is guaranteed to work on any number of threads > 0. You can even use nexts and shared nexts as join points so the need for explicit low-level synchronisation (mutexes and so-on) is reduced.

The game main pushes itself onto this thread pool as a root task. It creates the graphics and audio drivers, and prepares the resource cache (which can load from passed resource sources, defaulting to the file structure but this can be changed to custom sources, with a physfs-based system for loading from archives being included in the engine). Then it starts the state manager looping on the pool.

The state manager maintains a stack of states and a list of "event managers" that have two steps: dispatch, where they send out events, and poll, where they gather information about which events they need to dispatch. States maintain their own task graph for update and draw logic, which is passed to the state manager. The state manager does the following things in a series of steps every frame, with each sub-step being executed concurrently:

Step 0:
- Delete any removed managers from the system.

Step 1:
- Check if any states exist. If not, close main.

Step 2:
- Get the draw commands from each state
- Flush the inputs from the window.
- Update audio drivers if required.
- Dispatch the event managers.

Step 3:
- Update the logic for each state that can be updated by placing their logic into one long task chain (each state can be concurrent internally, but no two states will update at the same time).
- Flush the draw commands from step 2 onto the screen, updating the display.
- Poll the event managers.

The next step is to enqueue step 0 again. Due to the nature of the thread pool, this will effectively cause the system to loop again.

It's complete overkill, but still kinda nifty to play around with Plus it makes debugging in a multithreaded environment easier, because I can instantly rule out or link the problem to timing issues and crashes by dropping n to 1. If it still goes wrong, it's the code. If not, it's the threading. And it makes things easier to unit test and identify problems, you can just isolate chunks of the task "graph" to test.

Now I just need to actually make something with it XD Might refactor the task system out into a more std-like syntax first and release that separately...

[rutsber]

Does anyone know what is wrong with this code? It's supposed to find whether a number is prime or not. It's from a book on C++ programming, so I would assume it would work.

Spoiler (click to show/hide)

Code: [Select]

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    int n;  // Number to test for prime-ness
    int i;  // Loop counter
    int is_prime = true;    // Boolean flag
                            // Assume true for now.
   
    //Get a number from the keyboard.
   
    cout << "Enter a number and press ENTER: ";
    cin >> n;
   
    // Test for prime by checking for divisibility
    // by all whole numbers from 2 to sqrt(n).
   
    i = 2;
    while (i <= sqrt(n)) {    // While i is <= sqrt(n)
        if (n % i == 0)        // If i divides n,
                is_prime = false;        // n is not prime.
        i++;                            // Add 1 to i.
    }
   
    //Print results
   
    if (is_prime)
        cout << "Number is prime." << endl;
    else
        cout << "Number is not prime." << endl;
       
    system("PAUSE");
    return 0;
}

The error I'm getting is:

Spoiler (click to show/hide)

[Warning] In function 'int main()':
call of overloaded 'sqrt(
candidates are: double sqrt(double)
        long double std::sqrt(long
        float std::sqrt(float)

Ninja'd. I was working on including this before you posted. It's supposed to find out if a given number is prime or not.

[RulerOfNothing]

When you say something is wrong with the code, what exactly is happening (and what is supposed to happen)?

[fergus]

Changing

Code: [Select]

int n;
to

Code: [Select]

long n;
should work.

[Gatleos]

Hey, it's been a while since I posted in here. I was hoping to get some advice on something.

See, I'm currently in the process of coding a dating sim (Don't ask. I'm serious, DON'T ASK) and just realized how complicated even a simple dialogue tree could get with conditional statements and such. I'm really stumped, I've never coded something quite like this before. So, what do you guys think would be the best design pattern for an arbitrarily-extensible dialogue tree? Hard-coding each individual response and stringing together a web of function calls (or goto statements, oh god) seems like it would be insane to attempt and just bad design all-around.

The only thing I can think of is to make a simple scripting language that has a couple commands for inserting character expressions, sound effects, etc. and then loading it in and parsing it in real-time as the user moves through the dialogue tree. But I need to define a set of dialogue choices for each node on the tree too, and GAH

[kaijyuu]

Yeah I know what you mean. I've never coded something as comprehensive as a dating sim, but I have done branching dialog with NPCs and stuff, and the best way is to make a simple tool or scripting language. That way all you need to do is type in the dialog and flip some switches, and you've got a fully functional conversation.

I went with the "make a tool" method so I can keep track of everything, but having a text parser so you can write everything up (special commands and all) in notepad works too.