VD>Осталось без трепа изобразить решение.

x := alpha * p + omega * s;

#include <iostream>
#include <vector>

typedef std::vector< float > vector_t;

class delayed_scalar_by_vector_multiply_t
    {
    public :
        delayed_scalar_by_vector_multiply_t(
            float a,
            const vector_t & b )
            :    a_( a )
            ,    b_( b )
            {}

        float scalar() const { return a_; }
        const vector_t & vector() const { return b_; }

    private :
        float a_;
        const vector_t & b_;
    };

delayed_scalar_by_vector_multiply_t
operator*(
    float a,
    const vector_t & b )
    {
        return delayed_scalar_by_vector_multiply_t( a, b );
    }

class delayed_sum_of_scalar_to_vector_multiply_t
    {
    public :
        delayed_sum_of_scalar_to_vector_multiply_t(
            const delayed_scalar_by_vector_multiply_t & a,
            const delayed_scalar_by_vector_multiply_t & b )
            :    a_( a )
            ,    b_( b )
            {}

        void calc_and_store_to( vector_t & receiver ) const
            {
                if( a_.vector().size() != b_.vector().size() )
                    throw std::invalid_argument( "vectors must have the same size" );

                receiver.clear();
                receiver.reserve( a_.vector().size() );

                for( unsigned int i = 0, i_max = a_.vector().size();
                        i != i_max;
                        ++i )
                    receiver.push_back(
                            a_.vector()[ i ] * a_.scalar() +
                            b_.vector()[ i ] * b_.scalar() );
            }

    private :
        delayed_scalar_by_vector_multiply_t a_;
        delayed_scalar_by_vector_multiply_t b_;
    };

delayed_sum_of_scalar_to_vector_multiply_t
operator+(
    const delayed_scalar_by_vector_multiply_t & a,
    const delayed_scalar_by_vector_multiply_t & b )
    {
        return delayed_sum_of_scalar_to_vector_multiply_t( a, b );
    }

vector_t &
operator<<(
    vector_t & receiver,
    const delayed_sum_of_scalar_to_vector_multiply_t & sum )
    {
        sum.calc_and_store_to( receiver );
        return receiver;
    }

std::ostream &
operator<<(
    std::ostream & to,
    const vector_t & v )
    {
        for( unsigned int i = 0, i_max = v.size(); i != i_max; ++i )
            {
                if( i )
                    to << " ";
                to << v[ i ];
            }
        return to;
    }

void
main()
    {
        const int vector_size = 5;
        float a_src[ vector_size ] = { 1, 2, 3, 4, 5 };
        float b_src[ vector_size ] = { 0.5, 1.5, 2.5, 3.5, 4.5 };

        vector_t a( a_src, a_src + vector_size );
        vector_t b( b_src, b_src + vector_size );
        vector_t c;

        c << 0.0 * a + 2.0 * b;

        std::cout << c << std::endl;
    }

 val query = (
      select fields ("first" of characterVarying(50)) 
        from "person" where ("last" in "person")=="'D.'"
    )
    val res1 = db.executeStatement {
      query
    }

    Console.print("Whose last name is simply 'D.'?")
    for(val i <- res1;
        val f <- i.fields) {
      Console.println(f.content.sqlString);
    }

SELECT first FROM person WHERE person.last = 'D.'

ExecuteReaderLoop("SELECT first FROM person WHERE person.last = 'D.'", db);
    WritwLine(first);

def filterValue = ReadLine();
ExecuteReaderLoop("SELECT first FROM person WHERE person.last = filterValue", db);
    WritwLine(first);

VD>def filterValue = ReadLine();
VD>ExecuteReaderLoop("SELECT first FROM person WHERE person.last = filterValue", db);
VD>    WritwLine(first);
VD>

def filterValue = ReadLine();
ExecuteReaderLoop("SELECT first FROM person WHERE person.last = $filterValue", db);
    WritwLine(first);