Реализация анализатора (парсера) формул времени выполнения Опции Подписка на тему Сообщить другу Версия для печати Скачать тему Подписка на этот форум Режимы отображения Древовидный Переключить на: Стандартный Переключить на: Линейный

[AntonTatu]

Всем привет !

Вопрос в следующем, имеется прога которая генерирует некоторую формулу (формула меняет количество своих параметров в зависимости от исходных значений в программе ), в этой же проге есть массив который использует полученную формулу в дальнейших расчетах, хочется создать из формулы dll ку и потом ее вызывать в нужном месте программы, как это сделать? С вызовом полученной dll я вроде бы разобрался, а вот как научить прогу генерить dll ку понять не могу.

ЗЫ: Какие можно использовать компилятор/линковщик (минимум занимаемого места, требуемых для работы файлов, потдержка STL требуется)

Выручайте ! Спасибо !

[SABROG]

Как по скорости?

[AntonTatu]

Как по скорости?

на первый взгляд не плохо, наднях обязательно отпишусь...

Для сложения/умножения не принципиально.

спасибо еще раз !!!

[BRE]

Как по скорости?

на первый взгляд не плохо, наднях обязательно отпишусь...

Погонял тесты, при замене QStack на std::stack, получил увеличение производительности больше чем в 12 раз.

Раскрывающийся текст

#include <stack>

class MathStack
{              
public:        
        void   push( double var);
        double pop ();           

private:
        std::stack<double> m_stack;
};                                 

void MathStack::push( double var )
{                                 
        m_stack.push( var );      
}                                 

double MathStack::pop()
{                      
        double val = m_stack.top();
        m_stack.pop();             
        return val;                
}

[AD]

Погонял тесты, при замене QStack на std::stack, получил увеличение производительности больше чем в 12 раз.

Кстати, а почему так? С чем это связано?

[BRE]

Погонял тесты, при замене QStack на std::stack, получил увеличение производительности больше чем в 12 раз.

Кстати, а почему так? С чем это связано?

Пока не разбирался, сам в недоумении.
Будем посмотреть...

Посмотрел.
QStack построен на базе QVector, и при добавлении/удалении элемента постоянно делает resize вектора.
std::stack построен на std::deque, соответственно скорость добавления/удаления на высоте.

Сообщение отредактировал BRE - 9.3.2009, 22:20

[AntonTatu]

..получил увеличение производительности больше чем в 12 раз.

А что нужно сделать что бы переделать

Вот этот кусочек

f.addOp( new VarOp( &arr[ 0 ][ 4 ] ) );
f.addOp( new VarOp( &arr[ 3 ][ 7 ] ) );
f.addOp( new VarOp( &arr[ 7 ][ 1 ] ) );

на

на такой

f.addOp( new VarOp( &arr[ 0 ][ j ] ) );
f.addOp( new VarOp( &arr[ 3 ][ j ] ) );
f.addOp( new VarOp( &arr[ 7 ][ j ] ) );

т.е. необходимо создать формулу, посчитать ее,
j=0;
f.addOp( new VarOp( &arr[ 0 ][ j ] ) );
f.addOp( new VarOp( &arr[ 3 ][ j ] ) );
f.addOp( new VarOp( &arr[ 7 ][ j ] ) );
res = f.calc();
передвинуться на следующий j -й столбец массива arr, посчитать,
j : =j+1;
res = f.calc();
на следующий..
j : =j+1;
res = f.calc();
и т.д.

т.е. что бы появилась возможность "сдвигать" формулу и, не перестраивая формулу заново и не генерируя новый массив ?

Сообщение отредактировал AntonTatu - 10.3.2009, 17:36

[BRE]

т.е. что бы появилась возможность "сдвигать" формулу и, не перестраивая формулу заново и не генерируя новый массив ?

Ну барин ты задачки задаешь. (с)

Переделать операцию VarOp или сделать еще одну операцию (это набросок).

class VectorVarOp : public Oparation
{
public:
    VectorVarOp( const Vector &vec );

    void    run();
    void    setIndex( int i, int j );

private:
    Vector    &m_vector;
    int         m_i;
    int         m_j;
};

VectorVarOp::VectorVarOp( const Vector &vec )
    : m_vector( vec ), m_i( 0 ), m_j( 0 )
{
}

void VectorVarOp::run()
{
    m_stack.push( m_vector[ m_i ][ m_j ] );
}

void VectorVarOp::setIndex( int i, int j )
{
    m_i = i;
    m_j = j;
}

Таким образом можно наделать разных необходимых операций, ввести переменные и т.д.
Например, если у всех переменных необходимо изменять j, можно сделать такую операцию, которая это будет делать вызовом одной функции.
Думай пробуй.

[AntonTatu]

Ну барин ты задачки задаешь. (с)
.............................................
.............................................
Таким образом можно наделать разных необходимых операций, ввести переменные и т.д.
Например, если у всех переменных необходимо изменять j, можно сделать такую операцию, которая это будет делать вызовом одной функции.
Думай пробуй.

Да у самого голова уже пухнет , залез в такие дебри в которых мало что понимаю
Последний вопрос связанный вот с этим , и все....

вот эта часть

void AddOp::run()
{
    int v1 = m_stack.pop();
    int v2 = m_stack.pop();
    m_stack.push( v1 + v2 );
}

double Formula::calc() const
{
    // Выполнить все операции
    for( ListOp::ConstIterator iOp = m_ops.begin(); iOp != m_ops.end(); ++iOp ){
        (*iOp)->run();
    }
    // После выполнения на вершине арифметического стека результат
    return Operation::m_stack.pop();

как сделать так что бы при сложении если на стеке ( m_stack.push( v1 + v2 ) число больше ну к примеру 100 (или любого какое нравится) остановить подсчет Formula::calc() и вывести результат ?
я сделал так....

вот

//изменил этот класс так 
class Operation
{
public:
    virtual void  run() = 0;    //выполнить операцию
    virtual bool  exit() = 0;   //добавил проверку на выход

//изменил этот класс так 
class VarOp : public Operation
{
public:
    VarOp( int *var  );

    void    run();
    bool    exit();

//изменил этот класс так 
class AddOp : public Operation
{
public:
    void    run();
    bool    exit();
    bool flag;

//...............................................
void AddOp::run()
{
    int v1 = m_stack.pop();
    int v2 = m_stack.pop();
    m_stack.push( v1 + v2 );
    if (v1 >= 1) flag = false;
}


bool AddOp::exit()
{
   if (flag == false) 
   {
       return false;
   }else
   {
    return true;
   }
}

//изменил этот класс так
double Formula::calc() const
{
    // Выполнить все операции
    for( ListOp::ConstIterator iOp = m_ops.begin(); iOp != m_ops.end(); ++iOp ){
        (*iOp)->run();
        if (!(*iOp)->exit()) {
            break;

все работает как надо, но мне кажется что можно было както проще сделать ?

Сообщение отредактировал AntonTatu - 11.3.2009, 0:21

[BRE]

Мне кажется, что логичней, если сам метод run() будет сообщать нужно ли продолжать вычисления.

вот

class Operation
{
public:
    virtual bool  run() = 0;    //выполнить операцию, вернуть false - если необходимо прервать операцию
};

class VarOp : public Operation
{
public:
    VarOp( int *var  );

    bool    run();
};

class AddOp : public Operation
{
public:
    bool    run();
};

class DivOp : public Operation
{
public:
    bool    run();
};

//...............................................
void AddOp::run()
{
    int v1 = m_stack.pop();
    int v2 = m_stack.pop();
    m_stack.push( v1 + v2 );
    if (v1 >= 1) return false;

        return true;
}

// В операции деления проверяем, а не делим ли мы на 0!!!
void DivOp::run()
{
    int v1 = m_stack.pop();
        // Проверяем деление на 0!!!
        if( v1 == 0 )
                 return false;

    int v2 = m_stack.pop();
    m_stack.push( v2 / v1 );
    return true;
}

//изменил этот класс так
double Formula::calc() const
{
    // Выполнить все операции
    for( ListOp::ConstIterator iOp = m_ops.begin(); iOp != m_ops.end(); ++iOp )
        if( !(*iOp)->run() )
            break;
}

Еще желательно ввести методы для очистки стека, т.к. при таком прерывании операции возможны случаи, когда в стеке останутся данные.

Можно ввести такое понятие как контекст, в котором хранить арифметический стек, состояние (ошибка), исходные данные, локальные переменные.
Тогда мы бы избавились от статического стека и получили возможность пихать расчет формул по разным потокам.

Если будут еще вопросы задавай, мне самому интересен этот вопрос.

Сообщение отредактировал BRE - 11.3.2009, 8:39

[AntonTatu]

Мне кажется, что логичней, если сам метод run() будет сообщать нужно ли продолжать вычисления.

Так и знал что можно было огород не городить......с флажком...

Еще желательно ввести методы для очистки стека, т.к. при таком прерывании операции возможны случаи, когда в стеке останутся данные.

сделал так:

вот

void MathStack::clear()
{
   while (!m_stack.empty()){
       m_stack.pop(); //удаляем верхний элемент в стэке, который формально является последним элементом в контэйнере
     }

}

//и сюда добавил 

double Formula::calc() const
{
    //Очищаем стэк перед новым расчетом
    Operation::m_stack.clear(); //хотя заметил что перед новым расчетом стэк всегда пуст, даже если предыдущий выход из цикла был по брэйку...., 
                                             //наверно и очищать его не нужно.... и функция лишняя... ?

    // Выполнить все операции
    for( ListOp::ConstIterator iOp = m_ops.begin(); iOp != m_ops.end(); ++iOp ){
        (*iOp)->run();
        if (!(*iOp)->exit()) {
            break;

     //после выполнения на вершине арифметического стэка результат
     return Operation::m_stack.pop();

Если выход из цикла будет по break, то в стэке будет какой то результат, но в этом случае очищать его мне ненужно, т.к., я его в дальнейшем использую... (мне его наооборот получать нужно )

Можно ввести такое понятие как контекст, в котором хранить арифметический стек, состояние (ошибка), исходные данные, локальные переменные.
Тогда мы бы избавились от статического стека и получили возможность пихать расчет формул по разным потокам.
Если будут еще вопросы задавай, мне самому интересен этот вопрос.

вот это очень интересно, т.к. скорости мне все равно хочется больше... (если компилировать dll ку с массивом получается намного быстре, только компилятор таскать за собой не получится...)

[BRE]

//Очищаем стэк перед новым расчетом
//хотя заметил что перед новым расчетом стэк всегда пуст, даже если предыдущий выход из цикла был по брэйку....,
//наверно и очищать его не нужно.... и функция лишняя... ?

Вот смотри формула:
100 200 300 400 0 / * + +

происходит ошибка: Деление на 0, в стеке:
100 200 300 400

Тут от формулы зависит.

вот это очень интересно, т.к. скорости мне все равно хочется больше... (если компилировать dll ку с массивом получается намного быстре, только компилятор таскать за собой не получится...)

С нативом даже не сравнивай, не расстраивай себя. Такой производительности не будет.

Контексты набросаю чуть позже...