source/astexpr_arithmetic.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <cmath>
  20
  21 #include "astexprs.h"
  22 #include "shapesexceptions.h"
  23 #include "lighttypes.h"
  24 #include "globals.h"
  25
  26 using namespace Shapes;
  27 using namespace std;
  28
  29
  30 RefCountPtr< const Lang::Value >
  31 Ast::PlusPlusExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
  32 {
  33         if( arg1->val_ < 0 )
  34                 {
  35                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "Arguments to Pythagorean addition must be positive." ) );
  36                 }
  37         if( arg2->val_ < 0 )
  38                 {
  39                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Arguments to Pythagorean addition must be positive." ) );
  40                 }
  41         return RefCountPtr< const Lang::Value >( new Lang::Float( sqrt( (arg1->val_)*(arg1->val_) + (arg2->val_)*(arg2->val_) ) ) );
  42 }
  43
  44 RefCountPtr< const Lang::Value >
  45 Ast::PlusPlusExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
  46 {
  47         Concrete::Length tmp1 = arg1->get( );
  48         Concrete::Length tmp2 = arg2->get( );
  49         if( tmp1 < 0 )
  50                 {
  51                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "Arguments to Pythagorean addition must be positive." ) );
  52                 }
  53         if( tmp2 < 0 )
  54                 {
  55                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Arguments to Pythagorean addition must be positive." ) );
  56                 }
  57         return RefCountPtr< const Lang::Value >( new Lang::Length( hypotPhysical( tmp1, tmp2 ) ) );
  58 }
  59
  60
  61 RefCountPtr< const Lang::Value >
  62 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
  63 {
  64         if( arg1->val_ < 0 )
  65                 {
  66                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "Arguments to Pythagorean subtraction must be positive." ) );
  67                 }
  68         if( arg2->val_ < 0 )
  69                 {
  70                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Arguments to Pythagorean subtraction must be positive." ) );
  71                 }
  72         if( arg1->val_ < arg2->val_ )
  73                 {
  74                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "The first argument bust be greater than the second one in Pythagorean subtraction." ) );
  75                 }
  76         return RefCountPtr< const Lang::Value >( new Lang::Float( sqrt( (arg1->val_)*(arg1->val_) - (arg2->val_)*(arg2->val_) ) ) );
  77 }
  78
  79 RefCountPtr< const Lang::Value >
  80 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
  81 {
  82         Concrete::Length tmp1 = arg1->get( );
  83         Concrete::Length tmp2 = arg2->get( );
  84         if( tmp1 < 0 )
  85                 {
  86                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "Arguments to Pythagorean subtraction must be positive." ) );
  87                 }
  88         if( tmp2 < 0 )
  89                 {
  90                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Arguments to Pythagorean subtraction must be positive." ) );
  91                 }
  92         if( tmp1 < tmp2 )
  93                 {
  94                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "The first argument bust be greater than the second one in Pythagorean subtraction." ) );
  95                 }
  96         return RefCountPtr< const Lang::Value >( new Lang::Length( sqrtPhysical( tmp1*tmp1 - tmp2*tmp2 ) ) );
  97 }
  98
  99 RefCountPtr< const Lang::Value >
 100 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 101 {
 102         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 103 }
 104
 105 RefCountPtr< const Lang::Value >
 106 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::PathPoint2D ) arg2, const Kernel::PassedDyn & dyn ) const
 107 {
 108         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 109 }
 110
 111 RefCountPtr< const Lang::Value >
 112 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 113 {
 114         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 115 }
 116
 117 RefCountPtr< const Lang::Value >
 118 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Path2D ) arg2, const Kernel::PassedDyn & dyn ) const
 119 {
 120         if( arg2->isClosed( ) )
 121                 {
 122                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 123                 }
 124         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 125 }
 126
 127 RefCountPtr< const Lang::Value >
 128 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 129 {
 130         if( arg1->isClosed( ) )
 131                 {
 132                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 133                 }
 134         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 135 }
 136
 137 RefCountPtr< const Lang::Value >
 138 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint2D ) arg1, DUMMYANDREF( const Lang::PathPoint2D ) arg2, const Kernel::PassedDyn & dyn ) const
 139 {
 140         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 141 }
 142
 143 RefCountPtr< const Lang::Value >
 144 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint2D ) arg1, DUMMYANDREF( const Lang::Path2D ) arg2, const Kernel::PassedDyn & dyn ) const
 145 {
 146         if( arg2->isClosed( ) )
 147                 {
 148                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 149                 }
 150         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 151 }
 152
 153 RefCountPtr< const Lang::Value >
 154 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path2D ) arg1, DUMMYANDREF( const Lang::PathPoint2D ) arg2, const Kernel::PassedDyn & dyn ) const
 155 {
 156         if( arg1->isClosed( ) )
 157                 {
 158                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 159                 }
 160         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 161 }
 162
 163 RefCountPtr< const Lang::Value >
 164 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path2D ) arg1, DUMMYANDREF( const Lang::Path2D ) arg2, const Kernel::PassedDyn & dyn ) const
 165 {
 166         if( arg1->isClosed( ) )
 167                 {
 168                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 169                 }
 170         if( arg2->isClosed( ) )
 171                 {
 172                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 173                 }
 174         return Kernel::ValueRef( new Lang::Connection2D( arg1, arg2 ) );
 175 }
 176
 177 RefCountPtr< const Lang::Value >
 178 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 179 {
 180         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ),
 181                                                                                                                                                                                                                          RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 182 }
 183
 184 RefCountPtr< const Lang::Value >
 185 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::PathPoint3D ) arg2, const Kernel::PassedDyn & dyn ) const
 186 {
 187         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ),
 188                                                                                                                                                                                                                          RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 189 }
 190
 191 RefCountPtr< const Lang::Value >
 192 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 193 {
 194         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ),
 195                                                                                                                                                                                                                          RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 196 }
 197
 198 RefCountPtr< const Lang::Value >
 199 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Path3D ) arg2, const Kernel::PassedDyn & dyn ) const
 200 {
 201         if( arg2->isClosed( ) )
 202                 {
 203                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 204                 }
 205         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ), arg2 ) );
 206 }
 207
 208 RefCountPtr< const Lang::Value >
 209 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 210 {
 211         if( arg1->isClosed( ) )
 212                 {
 213                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 214                 }
 215         return Kernel::ValueRef( new Lang::Connection3D( arg1, RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 216 }
 217
 218 RefCountPtr< const Lang::Value >
 219 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint3D ) arg1, DUMMYANDREF( const Lang::PathPoint3D ) arg2, const Kernel::PassedDyn & dyn ) const
 220 {
 221         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ),
 222                                                                                                                                                                                                                          RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 223 }
 224
 225 RefCountPtr< const Lang::Value >
 226 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathPoint3D ) arg1, DUMMYANDREF( const Lang::Path3D ) arg2, const Kernel::PassedDyn & dyn ) const
 227 {
 228         if( arg2->isClosed( ) )
 229                 {
 230                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 231                 }
 232         return Kernel::ValueRef( new Lang::Connection3D( RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg1 ) ), arg2 ) );
 233 }
 234
 235 RefCountPtr< const Lang::Value >
 236 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path3D ) arg1, DUMMYANDREF( const Lang::PathPoint3D ) arg2, const Kernel::PassedDyn & dyn ) const
 237 {
 238         if( arg1->isClosed( ) )
 239                 {
 240                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 241                 }
 242         return Kernel::ValueRef( new Lang::Connection3D( arg1, RefCountPtr< Lang::Path3D >( new Lang::SinglePointPath3D( arg2 ) ) ) );
 243 }
 244
 245 RefCountPtr< const Lang::Value >
 246 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::Path3D ) arg1, DUMMYANDREF( const Lang::Path3D ) arg2, const Kernel::PassedDyn & dyn ) const
 247 {
 248         if( arg1->isClosed( ) )
 249                 {
 250                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 251                 }
 252         if( arg2->isClosed( ) )
 253                 {
 254                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Closed subpaths cannot be connected with." ) );
 255                 }
 256         return Kernel::ValueRef( new Lang::Connection3D( arg1, arg2 ) );
 257 }
 258
 259 RefCountPtr< const Lang::Value >
 260 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathSlider2D ) arg1, DUMMYANDREF( const Lang::PathSlider2D ) arg2, const Kernel::PassedDyn & dyn ) const
 261 {
 262         RefCountPtr< const Lang::ElementaryPath2D > path = arg1->getPath( );
 263         if( path != arg2->getPath( ) )
 264                 {
 265                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Cannot connect sliders that belong to different paths." ) );
 266                 }
 267
 268         if( arg1->getFront( ) != NullPtr< const Lang::Value >( ) )
 269                 {
 270                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "When connecting sliders, the rear slider cannot have a front handle." ) );
 271                 }
 272         if( arg2->getRear( ) != NullPtr< const Lang::Value >( ) )
 273                 {
 274                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "When connecting sliders, the front slider cannot have a rear handle." ) );
 275                 }
 276
 277         if( arg1->getRear( ) == NullPtr< const Lang::Value >( ) &&
 278                         arg2->getFront( ) == NullPtr< const Lang::Value >( ) )
 279                 {
 280                         return path->subpath( arg1->getTime( ), arg2->getTime( ) );
 281                 }
 282
 283         return Kernel::ValueRef( new Lang::HeadedPath2D( arg1->getRear( ), path->subpath( arg1->getTime( ), arg2->getTime( ) ), arg2->getFront( ) ) );
 284 }
 285
 286 RefCountPtr< const Lang::Value >
 287 Ast::MinusMinusExpr::impl( DUMMYANDREF( const Lang::PathSlider3D ) arg1, DUMMYANDREF( const Lang::PathSlider3D ) arg2, const Kernel::PassedDyn & dyn ) const
 288 {
 289         RefCountPtr< const Lang::ElementaryPath3D > path = arg1->getPath( );
 290         if( path != arg2->getPath( ) )
 291                 {
 292                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Cannot connect sliders that belong to different paths." ) );
 293                 }
 294
 295         if( arg1->getFront( ) != NullPtr< const Lang::Value >( ) )
 296                 {
 297                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "When connecting sliders, the rear slider cannot have a front handle." ) );
 298                 }
 299         if( arg2->getRear( ) != NullPtr< const Lang::Value >( ) )
 300                 {
 301                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "When connecting sliders, the front slider cannot have a rear handle." ) );
 302                 }
 303
 304         if( arg1->getRear( ) == NullPtr< const Lang::Value >( ) &&
 305                         arg2->getFront( ) == NullPtr< const Lang::Value >( ) )
 306                 {
 307                         return path->subpath( arg1->getTime( ), arg2->getTime( ) );
 308                 }
 309
 310         return Kernel::ValueRef( new Lang::HeadedPath3D( arg1->getRear( ), path->subpath( arg1->getTime( ), arg2->getTime( ) ), arg2->getFront( ) ) );
 311 }
 312
 313
 314
 315 RefCountPtr< const Lang::Value >
 316 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Path2D ) arg1, DUMMYANDREF( const Lang::Path2D ) arg2, const Kernel::PassedDyn & dyn ) const
 317 {
 318         Lang::MultiPath2D * res = new Lang::MultiPath2D;
 319         res->push_back( arg1 );
 320         res->push_back( arg2 );
 321         return RefCountPtr< Lang::Value >( res );
 322 }
 323
 324 RefCountPtr< const Lang::Value >
 325 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::MultiPath2D ) arg1, DUMMYANDREF( const Lang::Path2D ) arg2, const Kernel::PassedDyn & dyn ) const
 326 {
 327         Lang::MultiPath2D * res = arg1->clone( );
 328         res->push_back( arg2 );
 329         return RefCountPtr< Lang::Value >( res );
 330 }
 331
 332 RefCountPtr< const Lang::Value >
 333 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Path2D ) arg1, DUMMYANDREF( const Lang::MultiPath2D ) arg2, const Kernel::PassedDyn & dyn ) const
 334 {
 335         Lang::MultiPath2D * res = arg2->clone( );
 336         res->push_front( arg1 );
 337         return RefCountPtr< Lang::Value >( res );
 338 }
 339
 340 RefCountPtr< const Lang::Value >
 341 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::MultiPath2D ) arg1, DUMMYANDREF( const Lang::MultiPath2D ) arg2, const Kernel::PassedDyn & dyn ) const
 342 {
 343         Lang::MultiPath2D * res = arg1->clone( );
 344         typedef typeof( *arg2 ) ListType;
 345         for( ListType::const_iterator i = arg2->begin( ); i != arg2->end( ); ++i )
 346                 {
 347                         res->push_back( *i );
 348                 }
 349         return RefCountPtr< Lang::Value >( res );
 350 }
 351
 352 RefCountPtr< const Lang::Value >
 353 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Path3D ) arg1, DUMMYANDREF( const Lang::Path3D ) arg2, const Kernel::PassedDyn & dyn ) const
 354 {
 355         Lang::MultiPath3D * res = new Lang::MultiPath3D;
 356         res->push_back( arg1 );
 357         res->push_back( arg2 );
 358         return RefCountPtr< Lang::Value >( res );
 359 }
 360
 361 RefCountPtr< const Lang::Value >
 362 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::MultiPath3D ) arg1, DUMMYANDREF( const Lang::Path3D ) arg2, const Kernel::PassedDyn & dyn ) const
 363 {
 364         Lang::MultiPath3D * res = arg1->clone( );
 365         res->push_back( arg2 );
 366         return RefCountPtr< Lang::Value >( res );
 367 }
 368
 369 RefCountPtr< const Lang::Value >
 370 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Path3D ) arg1, DUMMYANDREF( const Lang::MultiPath3D ) arg2, const Kernel::PassedDyn & dyn ) const
 371 {
 372         Lang::MultiPath3D * res = arg2->clone( );
 373         res->push_front( arg1 );
 374         return RefCountPtr< Lang::Value >( res );
 375 }
 376
 377 RefCountPtr< const Lang::Value >
 378 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::MultiPath3D ) arg1, DUMMYANDREF( const Lang::MultiPath3D ) arg2, const Kernel::PassedDyn & dyn ) const
 379 {
 380         Lang::MultiPath3D * res = arg1->clone( );
 381         typedef typeof( *arg2 ) ListType;
 382         for( ListType::const_iterator i = arg2->begin( ); i != arg2->end( ); ++i )
 383                 {
 384                         res->push_back( *i );
 385                 }
 386         return RefCountPtr< Lang::Value >( res );
 387 }
 388
 389 RefCountPtr< const Lang::Value >
 390 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::DynamicBindings ) arg1, DUMMYANDREF( const Lang::DynamicBindings ) arg2, const Kernel::PassedDyn & dyn ) const
 391 {
 392         if( arg1 == Lang::THE_NULL_DYNAMIC_BINDINGS )
 393                 {
 394                         return arg2;
 395                 }
 396         if( arg2 == Lang::THE_NULL_DYNAMIC_BINDINGS )
 397                 {
 398                         return arg1;
 399                 }
 400         return RefCountPtr< Lang::DynamicBindings >( new Lang::DynamicBindingsPair( arg1, arg2 ) );
 401 }
 402
 403 RefCountPtr< const Lang::Value >
 404 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Drawable2D ) arg1, DUMMYANDREF( const Lang::Drawable2D ) arg2, const Kernel::PassedDyn & dyn ) const
 405 {
 406         RefCountPtr< const Kernel::GraphicsState > metaState = dyn->getGraphicsState( );
 407         return RefCountPtr< Lang::Group2D >( new Lang::GroupPair2D
 408                                                                                                                                                          ( arg2,
 409                                                                                                                                                                  RefCountPtr< Lang::Group2D >( new Lang::GroupPair2D
 410                                                                                                                                                                                                                                                                                          ( arg1,
 411                                                                                                                                                                                                                                                                                                  Lang::THE_NULL2D,
 412                                                                                                                                                                                                                                                                                                  metaState ) ),
 413                                                                                                                                                                  metaState ) );
 414 }
 415
 416 RefCountPtr< const Lang::Value >
 417 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Group2D ) arg1, DUMMYANDREF( const Lang::Drawable2D ) arg2, const Kernel::PassedDyn & dyn ) const
 418 {
 419         return RefCountPtr< Lang::Group2D >( new Lang::GroupPair2D( arg2, arg1, dyn->getGraphicsState( ) ) );
 420 }
 421
 422 RefCountPtr< const Lang::Value >
 423 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Drawable3D ) arg1, DUMMYANDREF( const Lang::Drawable3D ) arg2, const Kernel::PassedDyn & dyn ) const
 424 {
 425         RefCountPtr< const Kernel::GraphicsState > metaState = dyn->getGraphicsState( );
 426         return RefCountPtr< Lang::Group3D >( new Lang::GroupPair3D
 427                                                                                                                                                          ( arg2,
 428                                                                                                                                                                  RefCountPtr< Lang::Group3D >( new Lang::GroupPair3D
 429                                                                                                                                                                                                                                                                                          ( arg1,
 430                                                                                                                                                                                                                                                                                                  Lang::THE_NULL3D,
 431                                                                                                                                                                                                                                                                                                  metaState ) ),
 432                                                                                                                                                                  metaState ) );
 433 }
 434
 435 RefCountPtr< const Lang::Value >
 436 Ast::AmpersandExpr::impl( DUMMYANDREF( const Lang::Group3D ) arg1, DUMMYANDREF( const Lang::Drawable3D ) arg2, const Kernel::PassedDyn & dyn ) const
 437 {
 438         return RefCountPtr< Lang::Group3D >( new Lang::GroupPair3D( arg2, arg1, dyn->getGraphicsState( ) ) );
 439 }
 440
 441
 442 RefCountPtr< const Lang::Value >
 443 Ast::AmpersandMoreExpr::impl( DUMMYANDREF( const Lang::DynamicBindings ) arg1, DUMMYANDREF( const Lang::DynamicBindings ) arg2, const Kernel::PassedDyn & dyn ) const
 444 {
 445         if( arg1 == Lang::THE_NULL_DYNAMIC_BINDINGS )
 446                 {
 447                         return arg2;
 448                 }
 449         if( arg2 == Lang::THE_NULL_DYNAMIC_BINDINGS )
 450                 {
 451                         return arg1;
 452                 }
 453         return RefCountPtr< Lang::DynamicBindings >( new Lang::DynamicBindingsPair( arg1, arg2, true ) ); /* True means "second overrides first" */
 454 }
 455
 456
 457 RefCountPtr< const Lang::Value >
 458 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 459 {
 460         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ + arg2->val_ ) );
 461 }
 462
 463 RefCountPtr< const Lang::Value >
 464 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
 465 {
 466         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ + arg2->val_ ) );
 467 }
 468
 469 RefCountPtr< const Lang::Value >
 470 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 471 {
 472         return RefCountPtr< const Lang::Value >( new Lang::Length( *arg1 + *arg2 ) );
 473 }
 474
 475 RefCountPtr< const Lang::Value >
 476 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 477 {
 478         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ + arg2->x_, arg1->y_ + arg2->y_ ) );
 479 }
 480
 481 RefCountPtr< const Lang::Value >
 482 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 483 {
 484         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_ + arg2->x_, arg1->y_ + arg2->y_ ) );
 485 }
 486
 487 RefCountPtr< const Lang::Value >
 488 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 489 {
 490         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ + arg2->x_, arg1->y_ + arg2->y_, arg1->z_ + arg2->z_ ) );
 491 }
 492
 493 RefCountPtr< const Lang::Value >
 494 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 495 {
 496         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_ + arg2->x_, arg1->y_ + arg2->y_, arg1->z_ + arg2->z_ ) );
 497 }
 498
 499 RefCountPtr< const Lang::Value >
 500 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::String ) arg1, DUMMYANDREF( const Lang::String ) arg2, const Kernel::PassedDyn & dyn ) const
 501 {
 502         const char * src1 = arg1->val_.getPtr( );
 503         const char * src2 = arg2->val_.getPtr( );
 504         int l1 = strlen( src1 );
 505         char * mem = new char[ l1 + strlen( src2 ) + 1 ];
 506         strcpy( mem, src1 );
 507         strcpy( mem + l1, src2 );
 508         return RefCountPtr< const Lang::Value >( new Lang::String( mem, false ) );
 509 }
 510
 511 RefCountPtr< const Lang::Value >
 512 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Dash ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 513 {
 514         return arg1->shifted( arg2->get( ) );
 515 }
 516
 517 RefCountPtr< const Lang::Value >
 518 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Dash ) arg2, const Kernel::PassedDyn & dyn ) const
 519 {
 520         return arg2->shifted( arg1->get( ) );
 521 }
 522
 523 RefCountPtr< const Lang::Value >
 524 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::PathSlider2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 525 {
 526         return arg1->move_time( Concrete::Time( arg2->val_ ) );
 527 }
 528
 529 RefCountPtr< const Lang::Value >
 530 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::PathSlider2D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 531 {
 532         return arg1->move_length( arg2->get( ) );
 533 }
 534
 535 RefCountPtr< const Lang::Value >
 536 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::PathSlider3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 537 {
 538         return arg1->move_time( Concrete::Time( arg2->val_ ) );
 539 }
 540
 541 RefCountPtr< const Lang::Value >
 542 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::PathSlider3D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 543 {
 544         return arg1->move_length( arg2->get( ) );
 545 }
 546
 547 RefCountPtr< const Lang::Value >
 548 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::RGB ) arg1, DUMMYANDREF( const Lang::RGB ) arg2, const Kernel::PassedDyn & dyn ) const
 549 {
 550         return RefCountPtr< const Lang::Value >( new Lang::RGB( arg1->components( ).add( arg2->components( ), loc( ) ) ) );
 551 }
 552
 553 RefCountPtr< const Lang::Value >
 554 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::Gray ) arg1, DUMMYANDREF( const Lang::Gray ) arg2, const Kernel::PassedDyn & dyn ) const
 555 {
 556         return RefCountPtr< const Lang::Value >( new Lang::Gray( arg1->components( ).add( arg2->components( ), loc( ) ) ) );
 557 }
 558
 559 RefCountPtr< const Lang::Value >
 560 Ast::PlusExpr::impl( DUMMYANDREF( const Lang::SpecularReflection ) arg1, DUMMYANDREF( const Lang::SpecularReflection ) arg2, const Kernel::PassedDyn & dyn ) const
 561 {
 562         return RefCountPtr< const Lang::Value >( new Lang::SpecularReflectionPair( arg1, arg2 ) );
 563 }
 564
 565
 566 RefCountPtr< const Lang::Value >
 567 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 568 {
 569         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ - arg2->val_ ) );
 570 }
 571
 572 RefCountPtr< const Lang::Value >
 573 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
 574 {
 575         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ - arg2->val_ ) );
 576 }
 577
 578 RefCountPtr< const Lang::Value >
 579 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 580 {
 581         return RefCountPtr< const Lang::Value >( new Lang::Length( *arg1 - *arg2 ) );
 582 }
 583
 584 RefCountPtr< const Lang::Value >
 585 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 586 {
 587         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ - arg2->x_, arg1->y_ - arg2->y_ ) );
 588 }
 589
 590 RefCountPtr< const Lang::Value >
 591 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 592 {
 593         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_ - arg2->x_, arg1->y_ - arg2->y_ ) );
 594 }
 595
 596 RefCountPtr< const Lang::Value >
 597 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 598 {
 599         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ - arg2->x_, arg1->y_ - arg2->y_, arg1->z_ - arg2->z_ ) );
 600 }
 601
 602 RefCountPtr< const Lang::Value >
 603 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 604 {
 605         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_ - arg2->x_, arg1->y_ - arg2->y_, arg1->z_ - arg2->z_ ) );
 606 }
 607
 608 RefCountPtr< const Lang::Value >
 609 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::PathSlider2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 610 {
 611         return arg1->move_time( Concrete::Time( - arg2->val_ ) );
 612 }
 613
 614 RefCountPtr< const Lang::Value >
 615 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::PathSlider2D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 616 {
 617         return arg1->move_length( - arg2->get( ) );
 618 }
 619
 620 RefCountPtr< const Lang::Value >
 621 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::PathSlider3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 622 {
 623         return arg1->move_time( Concrete::Time( - arg2->val_ ) );
 624 }
 625
 626 RefCountPtr< const Lang::Value >
 627 Ast::MinusExpr::impl( DUMMYANDREF( const Lang::PathSlider3D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 628 {
 629         return arg1->move_length( - arg2->get( ) );
 630 }
 631
 632
 633 RefCountPtr< const Lang::Value >
 634 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 635 {
 636         double tmp = arg1->val_ * arg2->val_;
 637         if( tmp > 0 )
 638                 {
 639                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 640                 }
 641         if( tmp < 0 )
 642                 {
 643                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 644                 }
 645         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 646 }
 647
 648 RefCountPtr< const Lang::Value >
 649 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 650 {
 651         Concrete::Length tmp = arg1->val_ * arg2->get( );
 652         if( tmp > 0 )
 653                 {
 654                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 655                 }
 656         if( tmp < 0 )
 657                 {
 658                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 659                 }
 660         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 661 }
 662
 663 RefCountPtr< const Lang::Value >
 664 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 665 {
 666         Concrete::Length tmp = arg1->get( ) * arg2->val_;
 667         if( tmp > 0 )
 668                 {
 669                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 670                 }
 671         if( tmp < 0 )
 672                 {
 673                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 674                 }
 675         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 676 }
 677
 678 RefCountPtr< const Lang::Value >
 679 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 680 {
 681         Concrete::LengthSquared tmp = arg1->get( ) * arg2->get( );
 682         if( tmp > 0 )
 683                 {
 684                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 685                 }
 686         if( tmp < 0 )
 687                 {
 688                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 689                 }
 690         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 691 }
 692
 693 RefCountPtr< const Lang::Value >
 694 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 695 {
 696         const double x1 = arg1->x_;
 697         const double y1 = arg1->y_;
 698         const double x2 = arg2->x_;
 699         const double y2 = arg2->y_;
 700         double norm1 = hypot( x1, y1 );
 701         double norm2 = hypot( x2, y2 );
 702         if( norm1 == 0 || norm2 == 0 )
 703                 {
 704                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 705                 }
 706         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) ) ) ) );
 707 }
 708
 709 RefCountPtr< const Lang::Value >
 710 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 711 {
 712         const double x1 = arg1->x_;
 713         const double y1 = arg1->y_;
 714         const Concrete::Length x2 = arg2->x_.get( );
 715         const Concrete::Length y2 = arg2->y_.get( );
 716         double norm1 = hypot( x1, y1 );
 717         Concrete::Length norm2 = hypotPhysical( x2, y2 );
 718         if( norm1 == 0 || norm2 == 0 )
 719                 {
 720                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 721                 }
 722         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) ) ) ) );
 723 }
 724
 725 RefCountPtr< const Lang::Value >
 726 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 727 {
 728         const Concrete::Length x1 = arg1->x_.get( );
 729         const Concrete::Length y1 = arg1->y_.get( );
 730         const double x2 = arg2->x_;
 731         const double y2 = arg2->y_;
 732         Concrete::Length norm1 = hypotPhysical( x1, y1 );
 733         double norm2 = hypot( x2, y2 );
 734         if( norm1 == 0 || norm2 == 0 )
 735                 {
 736                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 737                 }
 738         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) ) ) ) );
 739 }
 740
 741 RefCountPtr< const Lang::Value >
 742 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 743 {
 744         const Concrete::Length x1 = arg1->x_.get( );
 745         const Concrete::Length y1 = arg1->y_.get( );
 746         const Concrete::Length x2 = arg2->x_.get( );
 747         const Concrete::Length y2 = arg2->y_.get( );
 748         Concrete::Length norm1 = hypotPhysical( x1, y1 );
 749         Concrete::Length norm2 = hypotPhysical( x2, y2 );
 750         if( norm1 == 0 || norm2 == 0 )
 751                 {
 752                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 753                 }
 754         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) ) ) ) );
 755 }
 756
 757 RefCountPtr< const Lang::Value >
 758 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 759 {
 760         const double x1 = arg1->x_;
 761         const double y1 = arg1->y_;
 762         const double z1 = arg1->z_;
 763         const double x2 = arg2->x_;
 764         const double y2 = arg2->y_;
 765         const double z2 = arg2->z_;
 766         double norm1 = Concrete::Scalar::hypot3( x1, y1, z1 );
 767         double norm2 = Concrete::Scalar::hypot3( x2, y2, z2 );
 768         if( norm1 == 0 || norm2 == 0 )
 769                 {
 770                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 771                 }
 772         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2) ) ) ) );
 773 }
 774
 775 RefCountPtr< const Lang::Value >
 776 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 777 {
 778         const double x1 = arg1->x_;
 779         const double y1 = arg1->y_;
 780         const double z1 = arg1->z_;
 781         const Concrete::Length x2 = arg2->x_.get( );
 782         const Concrete::Length y2 = arg2->y_.get( );
 783         const Concrete::Length z2 = arg2->z_.get( );
 784         double norm1 = Concrete::Scalar::hypot3( x1, y1, z1 );
 785         Concrete::Length norm2 = hypotPhysical( x2, y2, z2 );
 786         if( norm1 == 0 || norm2 == 0 )
 787                 {
 788                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 789                 }
 790         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2) ) ) ) );
 791 }
 792
 793 RefCountPtr< const Lang::Value >
 794 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 795 {
 796         const Concrete::Length x1 = arg1->x_.get( );
 797         const Concrete::Length y1 = arg1->y_.get( );
 798         const Concrete::Length z1 = arg1->z_.get( );
 799         const double x2 = arg2->x_;
 800         const double y2 = arg2->y_;
 801         const double z2 = arg2->z_;
 802         Concrete::Length norm1 = hypotPhysical( x1, y1, z1 );
 803         double norm2 = Concrete::Scalar::hypot3( x2, y2, z2 );
 804         if( norm1 == 0 || norm2 == 0 )
 805                 {
 806                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 807                 }
 808         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2) ) ) ) );
 809 }
 810
 811 RefCountPtr< const Lang::Value >
 812 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 813 {
 814         const Concrete::Length x1 = arg1->x_.get( );
 815         const Concrete::Length y1 = arg1->y_.get( );
 816         const Concrete::Length z1 = arg1->z_.get( );
 817         const Concrete::Length x2 = arg2->x_.get( );
 818         const Concrete::Length y2 = arg2->y_.get( );
 819         const Concrete::Length z2 = arg2->z_.get( );
 820         Concrete::Length norm1 = hypotPhysical( x1, y1, z1 );
 821         Concrete::Length norm2 = hypotPhysical( x2, y2, z2 );
 822         if( norm1 == 0 || norm2 == 0 )
 823                 {
 824                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 825                 }
 826         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( ( (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2) ) ) ) );
 827 }
 828
 829
 830 RefCountPtr< const Lang::Value >
 831 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 832 {
 833         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
 834 }
 835
 836 RefCountPtr< const Lang::Value >
 837 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 838 {
 839         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->x_ * arg2->x_ + arg1->y_ * arg2->y_ ) );
 840 }
 841
 842 RefCountPtr< const Lang::Value >
 843 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 844 {
 845         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ * arg2->val_, arg1->y_ * arg2->val_ ) );
 846 }
 847
 848 RefCountPtr< const Lang::Value >
 849 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 850 {
 851         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->val_ * arg2->x_, arg1->val_ * arg2->y_ ) );
 852 }
 853
 854 RefCountPtr< const Lang::Value >
 855 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 856 {
 857         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->x_ * arg2->x_ + arg1->y_ * arg2->y_ + arg1->z_ * arg2->z_ ) );
 858 }
 859
 860 RefCountPtr< const Lang::Value >
 861 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 862 {
 863         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ * arg2->val_, arg1->y_ * arg2->val_, arg1->z_ * arg2->val_ ) );
 864 }
 865
 866 RefCountPtr< const Lang::Value >
 867 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 868 {
 869         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->val_ * arg2->x_, arg1->val_ * arg2->y_, arg1->val_ * arg2->z_ ) );
 870 }
 871
 872 RefCountPtr< const Lang::Value >
 873 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 874 {
 875         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) * arg2->val_ ) );
 876 }
 877
 878 RefCountPtr< const Lang::Value >
 879 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 880 {
 881         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->val_ * arg2->get( ) ) );
 882 }
 883
 884 RefCountPtr< const Lang::Value >
 885 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 886 {
 887         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_.get( ) * arg2->val_, arg1->y_.get( ) * arg2->val_ ) );
 888 }
 889
 890 RefCountPtr< const Lang::Value >
 891 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 892 {
 893         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->val_ * arg2->x_.get( ), arg1->val_ * arg2->y_.get( ) ) );
 894 }
 895
 896 RefCountPtr< const Lang::Value >
 897 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 898 {
 899         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_.get( ) * arg2->x_ + arg1->y_.get( ) * arg2->y_ ) );
 900 }
 901
 902 RefCountPtr< const Lang::Value >
 903 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 904 {
 905         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_ * arg2->x_.get( ) + arg1->y_ * arg2->y_.get( ) ) );
 906 }
 907
 908 RefCountPtr< const Lang::Value >
 909 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 910 {
 911         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_ * arg2->get( ), arg1->y_ * arg2->get( ) ) );
 912 }
 913
 914 RefCountPtr< const Lang::Value >
 915 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 916 {
 917         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->get( ) * arg2->x_, arg1->get( ) * arg2->y_ ) );
 918 }
 919
 920 RefCountPtr< const Lang::Value >
 921 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 922 {
 923         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_.get( ) * arg2->val_, arg1->y_.get( ) * arg2->val_, arg1->z_.get( ) * arg2->val_ ) );
 924 }
 925
 926 RefCountPtr< const Lang::Value >
 927 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 928 {
 929         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->val_ * arg2->x_.get( ), arg1->val_ * arg2->y_.get( ), arg1->val_ * arg2->z_.get( ) ) );
 930 }
 931
 932 RefCountPtr< const Lang::Value >
 933 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 934 {
 935         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_.get( ) * arg2->x_ + arg1->y_.get( ) * arg2->y_ + arg1->z_.get( ) * arg2->z_ ) );
 936 }
 937
 938 RefCountPtr< const Lang::Value >
 939 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 940 {
 941         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_ * arg2->x_.get( ) + arg1->y_ * arg2->y_.get( ) + arg1->z_ * arg2->z_.get( ) ) );
 942 }
 943
 944 RefCountPtr< const Lang::Value >
 945 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 946 {
 947         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_ * arg2->get( ), arg1->y_ * arg2->get( ), arg1->z_ * arg2->get( ) ) );
 948 }
 949
 950 RefCountPtr< const Lang::Value >
 951 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 952 {
 953         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->get( ) * arg2->x_, arg1->get( ) * arg2->y_, arg1->get( ) * arg2->z_ ) );
 954 }
 955
 956 RefCountPtr< const Lang::Value >
 957 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Dash ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 958 {
 959         if( arg2->val_ <= 0 )
 960                 {
 961                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Dashpatterns can only be scaled by positive values" ) );
 962                 }
 963
 964         return arg1->scaled( arg2->val_ );
 965 }
 966
 967 RefCountPtr< const Lang::Value >
 968 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Dash ) arg2, const Kernel::PassedDyn & dyn ) const
 969 {
 970         if( arg1->val_ <= 0 )
 971                 {
 972                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Dashpatterns can only be scaled by positive values" ) );
 973                 }
 974
 975         return arg2->scaled( arg1->val_ );
 976 }
 977
 978 RefCountPtr< const Lang::Value >
 979 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Transform2D ) arg1, DUMMYANDREF( const Lang::Transform2D ) arg2, const Kernel::PassedDyn & dyn ) const
 980 {
 981         return RefCountPtr< const Lang::Value >( new Lang::Transform2D( *arg1, *arg2 ) );
 982 }
 983
 984 RefCountPtr< const Lang::Value >
 985 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Transform3D ) arg1, DUMMYANDREF( const Lang::Transform3D ) arg2, const Kernel::PassedDyn & dyn ) const
 986 {
 987         return RefCountPtr< const Lang::Value >( new Lang::Transform3D( *arg1, *arg2 ) );
 988 }
 989
 990 RefCountPtr< const Lang::Value >
 991 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::RGB ) arg2, const Kernel::PassedDyn & dyn ) const
 992 {
 993         return RefCountPtr< const Lang::Value >( new Lang::RGB( arg2->components( ).mul( arg1->val_, expr1_->loc( ) ) ) );
 994 }
 995
 996 RefCountPtr< const Lang::Value >
 997 Ast::StarExpr::impl( DUMMYANDREF( const Lang::RGB ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 998 {
 999         return RefCountPtr< const Lang::Value >( new Lang::RGB( arg1->components( ).mul( arg2->val_, expr1_->loc( ) ) ) );
1000 }
1001
1002 RefCountPtr< const Lang::Value >
1003 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Gray ) arg2, const Kernel::PassedDyn & dyn ) const
1004 {
1005         return RefCountPtr< const Lang::Value >( new Lang::Gray( arg2->components( ).mul( arg1->val_, expr1_->loc( ) ) ) );
1006 }
1007
1008 RefCountPtr< const Lang::Value >
1009 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Gray ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1010 {
1011         return RefCountPtr< const Lang::Value >( new Lang::Gray( arg1->components( ).mul( arg2->val_, expr1_->loc( ) ) ) );
1012 }
1013
1014 RefCountPtr< const Lang::Value >
1015 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::SpecularReflection ) arg2, const Kernel::PassedDyn & dyn ) const
1016 {
1017         double scalar = arg1->val_;
1018         if( scalar < 0 || scalar > 1 )
1019                 {
1020                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "The scalar must be in the interval [ 0, 1 ]." ) );
1021                 }
1022         return arg2->multiply( scalar );
1023 }
1024
1025 RefCountPtr< const Lang::Value >
1026 Ast::StarExpr::impl( DUMMYANDREF( const Lang::SpecularReflection ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1027 {
1028         double scalar = arg2->val_;
1029         if( scalar < 0 || scalar > 1 )
1030                 {
1031                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "The scalar must be in the interval [ 0, 1 ]." ) );
1032                 }
1033         return arg1->multiply( scalar );
1034 }
1035
1036 RefCountPtr< const Lang::Value >
1037 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1038 {
1039         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ * arg2->val_ ) );
1040 }
1041
1042 RefCountPtr< const Lang::Value >
1043 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1044 {
1045         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
1046 }
1047
1048 RefCountPtr< const Lang::Value >
1049 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1050 {
1051         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
1052 }
1053
1054 RefCountPtr< const Lang::Value >
1055 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1056 {
1057         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) * arg2->val_ ) );
1058 }
1059
1060 RefCountPtr< const Lang::Value >
1061 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1062 {
1063         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->val_ * arg2->get( ) ) );
1064 }
1065
1066
1067 RefCountPtr< const Lang::Value >
1068 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
1069 {
1070         const double x1 = arg1->x_;
1071         const double y1 = arg1->y_;
1072         const double x2 = arg2->x_;
1073         const double y2 = arg2->y_;
1074         double norm2_2 = x2 * x2 + y2 * y2;
1075         if( norm2_2 == 0 )
1076                 {
1077                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1078                 }
1079         double s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1080         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( s * x2, s * y2 ) );
1081 }
1082
1083 RefCountPtr< const Lang::Value >
1084 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
1085 {
1086         const double x1 = arg1->x_;
1087         const double y1 = arg1->y_;
1088         const Concrete::Length x2 = arg2->x_.get( );
1089         const Concrete::Length y2 = arg2->y_.get( );
1090         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2;
1091         if( norm2_2 == 0 )
1092                 {
1093                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1094                 }
1095         Physical< -1, 0 > s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1096         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( s * x2, s * y2 ) );
1097 }
1098
1099 RefCountPtr< const Lang::Value >
1100 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
1101 {
1102         const Concrete::Length x1 = arg1->x_.get( );
1103         const Concrete::Length y1 = arg1->y_.get( );
1104         const double x2 = arg2->x_;
1105         const double y2 = arg2->y_;
1106         const double norm2_2 = x2 * x2 + y2 * y2;
1107         if( norm2_2 == 0 )
1108                 {
1109                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1110                 }
1111         Concrete::Length s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1112         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( s * x2, s * y2 ) );
1113 }
1114
1115 RefCountPtr< const Lang::Value >
1116 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
1117 {
1118         const Concrete::Length x1 = arg1->x_.get( );
1119         const Concrete::Length y1 = arg1->y_.get( );
1120         const Concrete::Length x2 = arg2->x_.get( );
1121         const Concrete::Length y2 = arg2->y_.get( );
1122         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2;
1123         if( norm2_2 == 0 )
1124                 {
1125                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1126                 }
1127         double s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1128         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( s * x2, s * y2 ) );
1129 }
1130
1131 RefCountPtr< const Lang::Value >
1132 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1133 {
1134         const double x1 = arg1->x_;
1135         const double y1 = arg1->y_;
1136         const double z1 = arg1->z_;
1137         const double x2 = arg2->x_;
1138         const double y2 = arg2->y_;
1139         const double z2 = arg2->z_;
1140         double norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1141         if( norm2_2 == 0 )
1142                 {
1143                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1144                 }
1145         double s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1146         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( s * x2, s * y2, s * z2 ) );
1147 }
1148
1149 RefCountPtr< const Lang::Value >
1150 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1151 {
1152         const double x1 = arg1->x_;
1153         const double y1 = arg1->y_;
1154         const double z1 = arg1->z_;
1155         const Concrete::Length x2 = arg2->x_.get( );
1156         const Concrete::Length y2 = arg2->y_.get( );
1157         const Concrete::Length z2 = arg2->z_.get( );
1158         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1159         if( norm2_2 == 0 )
1160                 {
1161                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1162                 }
1163         Physical< -1, 0 > s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1164         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( s * x2, s * y2, s * z2 ) );
1165 }
1166
1167 RefCountPtr< const Lang::Value >
1168 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1169 {
1170         const Concrete::Length x1 = arg1->x_.get( );
1171         const Concrete::Length y1 = arg1->y_.get( );
1172         const Concrete::Length z1 = arg1->z_.get( );
1173         const double x2 = arg2->x_;
1174         const double y2 = arg2->y_;
1175         const double z2 = arg2->z_;
1176         const double norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1177         if( norm2_2 == 0 )
1178                 {
1179                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1180                 }
1181         Concrete::Length s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1182         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( s * x2, s * y2, s * z2 ) );
1183 }
1184
1185 RefCountPtr< const Lang::Value >
1186 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1187 {
1188         const Concrete::Length x1 = arg1->x_.get( );
1189         const Concrete::Length y1 = arg1->y_.get( );
1190         const Concrete::Length z1 = arg1->z_.get( );
1191         const Concrete::Length x2 = arg2->x_.get( );
1192         const Concrete::Length y2 = arg2->y_.get( );
1193         const Concrete::Length z2 = arg2->z_.get( );
1194         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1195         if( norm2_2 == 0 )
1196                 {
1197                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1198                 }
1199         double s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1200         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( s * x2, s * y2, s * z2 ) );
1201 }
1202
1203
1204 RefCountPtr< const Lang::Value >
1205 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1206 {
1207         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ / arg2->val_ ) );
1208 }
1209
1210 RefCountPtr< const Lang::Value >
1211 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1212 {
1213         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->get( ) / arg2->get( ) ) );
1214 }
1215
1216 RefCountPtr< const Lang::Value >
1217 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1218 {
1219         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) / arg2->val_ ) );
1220 }
1221
1222 RefCountPtr< const Lang::Value >
1223 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1224 {
1225         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ / arg2->val_, arg1->y_ / arg2->val_ ) );
1226 }
1227
1228 RefCountPtr< const Lang::Value >
1229 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1230 {
1231         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_.get( ) / arg2->val_, arg1->y_.get( ) / arg2->val_ ) );
1232 }
1233
1234 RefCountPtr< const Lang::Value >
1235 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1236 {
1237         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_.get( ) / arg2->get( ), arg1->y_.get( ) / arg2->get( ) ) );
1238 }
1239
1240 RefCountPtr< const Lang::Value >
1241 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1242 {
1243         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ / arg2->val_, arg1->y_ / arg2->val_, arg1->z_ / arg2->val_ ) );
1244 }
1245
1246 RefCountPtr< const Lang::Value >
1247 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1248 {
1249         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_.get( ) / arg2->val_, arg1->y_.get( ) / arg2->val_, arg1->z_.get( ) / arg2->val_ ) );
1250 }
1251
1252 RefCountPtr< const Lang::Value >
1253 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1254 {
1255         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_.get( ) / arg2->get( ), arg1->y_.get( ) / arg2->get( ), arg1->z_.get( ) / arg2->get( ) ) );
1256 }
1257
1258 RefCountPtr< const Lang::Value >
1259 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1260 {
1261         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ / arg2->val_ ) );
1262 }
1263
1264 RefCountPtr< const Lang::Value >
1265 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1266 {
1267         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ / arg2->val_ ) );
1268 }
1269
1270 RefCountPtr< const Lang::Value >
1271 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1272 {
1273         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) / static_cast< double >( arg2->val_ ) ) );
1274 }
1275
1276
1277 RefCountPtr< const Lang::Value >
1278 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Transform2D ) arg1, DUMMYANDREF( const Lang::Transform2D ) arg2, const Kernel::PassedDyn & dyn ) const
1279 {
1280         return RefCountPtr< const Lang::Value >( new Lang::Transform2D( *arg1, *arg2 ) );
1281 }
1282
1283 RefCountPtr< const Lang::Value >
1284 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Transform3D ) arg1, DUMMYANDREF( const Lang::Transform3D ) arg2, const Kernel::PassedDyn & dyn ) const
1285 {
1286         return RefCountPtr< const Lang::Value >( new Lang::Transform3D( *arg1, *arg2 ) );
1287 }
1288
1289 RefCountPtr< const Lang::Value >
1290 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Function ) arg1, DUMMYANDREF( const Lang::Function ) arg2, const Kernel::PassedDyn & dyn ) const
1291 {
1292         return RefCountPtr< const Lang::Value >( new Lang::ComposedFunction( arg1, arg2 ) );
1293 }