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         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2);
 707         if( cosTmp >= 1 )
 708                 {
 709                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 710                 }
 711         else if( cosTmp <= -1 )
 712                 {
 713                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 714                 }
 715         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 716 }
 717
 718 RefCountPtr< const Lang::Value >
 719 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 720 {
 721         const double x1 = arg1->x_;
 722         const double y1 = arg1->y_;
 723         const Concrete::Length x2 = arg2->x_.get( );
 724         const Concrete::Length y2 = arg2->y_.get( );
 725         double norm1 = hypot( x1, y1 );
 726         Concrete::Length norm2 = hypotPhysical( x2, y2 );
 727         if( norm1 == 0 || norm2 == 0 )
 728                 {
 729                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 730                 }
 731         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2);
 732         if( cosTmp >= 1 )
 733                 {
 734                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 735                 }
 736         else if( cosTmp <= -1 )
 737                 {
 738                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 739                 }
 740         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 741 }
 742
 743 RefCountPtr< const Lang::Value >
 744 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 745 {
 746         const Concrete::Length x1 = arg1->x_.get( );
 747         const Concrete::Length y1 = arg1->y_.get( );
 748         const double x2 = arg2->x_;
 749         const double y2 = arg2->y_;
 750         Concrete::Length norm1 = hypotPhysical( x1, y1 );
 751         double norm2 = hypot( x2, y2 );
 752         if( norm1 == 0 || norm2 == 0 )
 753                 {
 754                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 755                 }
 756         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2);
 757         if( cosTmp >= 1 )
 758                 {
 759                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 760                 }
 761         else if( cosTmp <= -1 )
 762                 {
 763                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 764                 }
 765         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 766 }
 767
 768 RefCountPtr< const Lang::Value >
 769 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 770 {
 771         const Concrete::Length x1 = arg1->x_.get( );
 772         const Concrete::Length y1 = arg1->y_.get( );
 773         const Concrete::Length x2 = arg2->x_.get( );
 774         const Concrete::Length y2 = arg2->y_.get( );
 775         Concrete::Length norm1 = hypotPhysical( x1, y1 );
 776         Concrete::Length norm2 = hypotPhysical( x2, y2 );
 777         if( norm1 == 0 || norm2 == 0 )
 778                 {
 779                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 780                 }
 781         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2);
 782         if( cosTmp >= 1 )
 783                 {
 784                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 785                 }
 786         else if( cosTmp <= -1 )
 787                 {
 788                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 789                 }
 790         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 791 }
 792
 793 RefCountPtr< const Lang::Value >
 794 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 795 {
 796         const double x1 = arg1->x_;
 797         const double y1 = arg1->y_;
 798         const double z1 = arg1->z_;
 799         const double x2 = arg2->x_;
 800         const double y2 = arg2->y_;
 801         const double z2 = arg2->z_;
 802         double norm1 = Concrete::Scalar::hypot3( 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         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2);
 809         if( cosTmp >= 1 )
 810                 {
 811                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 812                 }
 813         else if( cosTmp <= -1 )
 814                 {
 815                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 816                 }
 817         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 818 }
 819
 820 RefCountPtr< const Lang::Value >
 821 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 822 {
 823         const double x1 = arg1->x_;
 824         const double y1 = arg1->y_;
 825         const double z1 = arg1->z_;
 826         const Concrete::Length x2 = arg2->x_.get( );
 827         const Concrete::Length y2 = arg2->y_.get( );
 828         const Concrete::Length z2 = arg2->z_.get( );
 829         double norm1 = Concrete::Scalar::hypot3( x1, y1, z1 );
 830         Concrete::Length norm2 = hypotPhysical( x2, y2, z2 );
 831         if( norm1 == 0 || norm2 == 0 )
 832                 {
 833                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 834                 }
 835         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2);
 836         if( cosTmp >= 1 )
 837                 {
 838                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 839                 }
 840         else if( cosTmp <= -1 )
 841                 {
 842                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 843                 }
 844         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 845 }
 846
 847 RefCountPtr< const Lang::Value >
 848 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 849 {
 850         const Concrete::Length x1 = arg1->x_.get( );
 851         const Concrete::Length y1 = arg1->y_.get( );
 852         const Concrete::Length z1 = arg1->z_.get( );
 853         const double x2 = arg2->x_;
 854         const double y2 = arg2->y_;
 855         const double z2 = arg2->z_;
 856         Concrete::Length norm1 = hypotPhysical( x1, y1, z1 );
 857         double norm2 = Concrete::Scalar::hypot3( x2, y2, z2 );
 858         if( norm1 == 0 || norm2 == 0 )
 859                 {
 860                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 861                 }
 862         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2);
 863         if( cosTmp >= 1 )
 864                 {
 865                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 866                 }
 867         else if( cosTmp <= -1 )
 868                 {
 869                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 870                 }
 871         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 872 }
 873
 874 RefCountPtr< const Lang::Value >
 875 Ast::AngleExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
 876 {
 877         const Concrete::Length x1 = arg1->x_.get( );
 878         const Concrete::Length y1 = arg1->y_.get( );
 879         const Concrete::Length z1 = arg1->z_.get( );
 880         const Concrete::Length x2 = arg2->x_.get( );
 881         const Concrete::Length y2 = arg2->y_.get( );
 882         const Concrete::Length z2 = arg2->z_.get( );
 883         Concrete::Length norm1 = hypotPhysical( x1, y1, z1 );
 884         Concrete::Length norm2 = hypotPhysical( x2, y2, z2 );
 885         if( norm1 == 0 || norm2 == 0 )
 886                 {
 887                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI_2 ) );
 888                 }
 889         double cosTmp = (x1/norm1) * (x2/norm2) + (y1/norm1) * (y2/norm2) + (z1/norm1) * (z2/norm2);
 890         if( cosTmp >= 1 )
 891                 {
 892                         return RefCountPtr< const Lang::Value >( new Lang::Float( 0 ) );
 893                 }
 894         else if( cosTmp <= -1 )
 895                 {
 896                         return RefCountPtr< const Lang::Value >( new Lang::Float( M_PI ) );
 897                 }
 898         return RefCountPtr< const Lang::Value >( new Lang::Float( acos( cosTmp ) ) );
 899 }
 900
 901
 902 RefCountPtr< const Lang::Value >
 903 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 904 {
 905         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
 906 }
 907
 908 RefCountPtr< const Lang::Value >
 909 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 910 {
 911         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->x_ * arg2->x_ + arg1->y_ * arg2->y_ ) );
 912 }
 913
 914 RefCountPtr< const Lang::Value >
 915 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 916 {
 917         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ * arg2->val_, arg1->y_ * arg2->val_ ) );
 918 }
 919
 920 RefCountPtr< const Lang::Value >
 921 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 922 {
 923         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->val_ * arg2->x_, arg1->val_ * arg2->y_ ) );
 924 }
 925
 926 RefCountPtr< const Lang::Value >
 927 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 928 {
 929         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->x_ * arg2->x_ + arg1->y_ * arg2->y_ + arg1->z_ * arg2->z_ ) );
 930 }
 931
 932 RefCountPtr< const Lang::Value >
 933 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 934 {
 935         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ * arg2->val_, arg1->y_ * arg2->val_, arg1->z_ * arg2->val_ ) );
 936 }
 937
 938 RefCountPtr< const Lang::Value >
 939 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
 940 {
 941         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->val_ * arg2->x_, arg1->val_ * arg2->y_, arg1->val_ * arg2->z_ ) );
 942 }
 943
 944 RefCountPtr< const Lang::Value >
 945 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 946 {
 947         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) * arg2->val_ ) );
 948 }
 949
 950 RefCountPtr< const Lang::Value >
 951 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 952 {
 953         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->val_ * arg2->get( ) ) );
 954 }
 955
 956 RefCountPtr< const Lang::Value >
 957 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 958 {
 959         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_.get( ) * arg2->val_, arg1->y_.get( ) * arg2->val_ ) );
 960 }
 961
 962 RefCountPtr< const Lang::Value >
 963 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 964 {
 965         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->val_ * arg2->x_.get( ), arg1->val_ * arg2->y_.get( ) ) );
 966 }
 967
 968 RefCountPtr< const Lang::Value >
 969 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 970 {
 971         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_.get( ) * arg2->x_ + arg1->y_.get( ) * arg2->y_ ) );
 972 }
 973
 974 RefCountPtr< const Lang::Value >
 975 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
 976 {
 977         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_ * arg2->x_.get( ) + arg1->y_ * arg2->y_.get( ) ) );
 978 }
 979
 980 RefCountPtr< const Lang::Value >
 981 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
 982 {
 983         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_ * arg2->get( ), arg1->y_ * arg2->get( ) ) );
 984 }
 985
 986 RefCountPtr< const Lang::Value >
 987 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
 988 {
 989         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->get( ) * arg2->x_, arg1->get( ) * arg2->y_ ) );
 990 }
 991
 992 RefCountPtr< const Lang::Value >
 993 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
 994 {
 995         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_.get( ) * arg2->val_, arg1->y_.get( ) * arg2->val_, arg1->z_.get( ) * arg2->val_ ) );
 996 }
 997
 998 RefCountPtr< const Lang::Value >
 999 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1000 {
1001         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->val_ * arg2->x_.get( ), arg1->val_ * arg2->y_.get( ), arg1->val_ * arg2->z_.get( ) ) );
1002 }
1003
1004 RefCountPtr< const Lang::Value >
1005 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1006 {
1007         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_.get( ) * arg2->x_ + arg1->y_.get( ) * arg2->y_ + arg1->z_.get( ) * arg2->z_ ) );
1008 }
1009
1010 RefCountPtr< const Lang::Value >
1011 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1012 {
1013         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->x_ * arg2->x_.get( ) + arg1->y_ * arg2->y_.get( ) + arg1->z_ * arg2->z_.get( ) ) );
1014 }
1015
1016 RefCountPtr< const Lang::Value >
1017 Ast::StarExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1018 {
1019         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_ * arg2->get( ), arg1->y_ * arg2->get( ), arg1->z_ * arg2->get( ) ) );
1020 }
1021
1022 RefCountPtr< const Lang::Value >
1023 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1024 {
1025         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->get( ) * arg2->x_, arg1->get( ) * arg2->y_, arg1->get( ) * arg2->z_ ) );
1026 }
1027
1028 RefCountPtr< const Lang::Value >
1029 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Dash ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1030 {
1031         if( arg2->val_ <= 0 )
1032                 {
1033                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Dashpatterns can only be scaled by positive values" ) );
1034                 }
1035
1036         return arg1->scaled( arg2->val_ );
1037 }
1038
1039 RefCountPtr< const Lang::Value >
1040 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Dash ) arg2, const Kernel::PassedDyn & dyn ) const
1041 {
1042         if( arg1->val_ <= 0 )
1043                 {
1044                         throw Exceptions::OutOfRange( this->loc( ), strrefdup( "Dashpatterns can only be scaled by positive values" ) );
1045                 }
1046
1047         return arg2->scaled( arg1->val_ );
1048 }
1049
1050 RefCountPtr< const Lang::Value >
1051 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Transform2D ) arg1, DUMMYANDREF( const Lang::Transform2D ) arg2, const Kernel::PassedDyn & dyn ) const
1052 {
1053         return RefCountPtr< const Lang::Value >( new Lang::Transform2D( *arg1, *arg2 ) );
1054 }
1055
1056 RefCountPtr< const Lang::Value >
1057 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Transform3D ) arg1, DUMMYANDREF( const Lang::Transform3D ) arg2, const Kernel::PassedDyn & dyn ) const
1058 {
1059         return RefCountPtr< const Lang::Value >( new Lang::Transform3D( *arg1, *arg2 ) );
1060 }
1061
1062 RefCountPtr< const Lang::Value >
1063 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::RGB ) arg2, const Kernel::PassedDyn & dyn ) const
1064 {
1065         return RefCountPtr< const Lang::Value >( new Lang::RGB( arg2->components( ).mul( arg1->val_, expr1_->loc( ) ) ) );
1066 }
1067
1068 RefCountPtr< const Lang::Value >
1069 Ast::StarExpr::impl( DUMMYANDREF( const Lang::RGB ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1070 {
1071         return RefCountPtr< const Lang::Value >( new Lang::RGB( arg1->components( ).mul( arg2->val_, expr1_->loc( ) ) ) );
1072 }
1073
1074 RefCountPtr< const Lang::Value >
1075 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Gray ) arg2, const Kernel::PassedDyn & dyn ) const
1076 {
1077         return RefCountPtr< const Lang::Value >( new Lang::Gray( arg2->components( ).mul( arg1->val_, expr1_->loc( ) ) ) );
1078 }
1079
1080 RefCountPtr< const Lang::Value >
1081 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Gray ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1082 {
1083         return RefCountPtr< const Lang::Value >( new Lang::Gray( arg1->components( ).mul( arg2->val_, expr1_->loc( ) ) ) );
1084 }
1085
1086 RefCountPtr< const Lang::Value >
1087 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::SpecularReflection ) arg2, const Kernel::PassedDyn & dyn ) const
1088 {
1089         double scalar = arg1->val_;
1090         if( scalar < 0 || scalar > 1 )
1091                 {
1092                         throw Exceptions::OutOfRange( expr1_->loc( ), strrefdup( "The scalar must be in the interval [ 0, 1 ]." ) );
1093                 }
1094         return arg2->multiply( scalar );
1095 }
1096
1097 RefCountPtr< const Lang::Value >
1098 Ast::StarExpr::impl( DUMMYANDREF( const Lang::SpecularReflection ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1099 {
1100         double scalar = arg2->val_;
1101         if( scalar < 0 || scalar > 1 )
1102                 {
1103                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "The scalar must be in the interval [ 0, 1 ]." ) );
1104                 }
1105         return arg1->multiply( scalar );
1106 }
1107
1108 RefCountPtr< const Lang::Value >
1109 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1110 {
1111         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ * arg2->val_ ) );
1112 }
1113
1114 RefCountPtr< const Lang::Value >
1115 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1116 {
1117         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
1118 }
1119
1120 RefCountPtr< const Lang::Value >
1121 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1122 {
1123         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ * arg2->val_ ) );
1124 }
1125
1126 RefCountPtr< const Lang::Value >
1127 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1128 {
1129         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) * arg2->val_ ) );
1130 }
1131
1132 RefCountPtr< const Lang::Value >
1133 Ast::StarExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1134 {
1135         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->val_ * arg2->get( ) ) );
1136 }
1137
1138
1139 RefCountPtr< const Lang::Value >
1140 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
1141 {
1142         const double x1 = arg1->x_;
1143         const double y1 = arg1->y_;
1144         const double x2 = arg2->x_;
1145         const double y2 = arg2->y_;
1146         double norm2_2 = x2 * x2 + y2 * y2;
1147         if( norm2_2 == 0 )
1148                 {
1149                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1150                 }
1151         double s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1152         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( s * x2, s * y2 ) );
1153 }
1154
1155 RefCountPtr< const Lang::Value >
1156 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
1157 {
1158         const double x1 = arg1->x_;
1159         const double y1 = arg1->y_;
1160         const Concrete::Length x2 = arg2->x_.get( );
1161         const Concrete::Length y2 = arg2->y_.get( );
1162         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2;
1163         if( norm2_2 == 0 )
1164                 {
1165                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1166                 }
1167         Physical< -1, 0 > s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1168         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( s * x2, s * y2 ) );
1169 }
1170
1171 RefCountPtr< const Lang::Value >
1172 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::FloatPair ) arg2, const Kernel::PassedDyn & dyn ) const
1173 {
1174         const Concrete::Length x1 = arg1->x_.get( );
1175         const Concrete::Length y1 = arg1->y_.get( );
1176         const double x2 = arg2->x_;
1177         const double y2 = arg2->y_;
1178         const double norm2_2 = x2 * x2 + y2 * y2;
1179         if( norm2_2 == 0 )
1180                 {
1181                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1182                 }
1183         Concrete::Length s = ( x1 * x2 + y1 * y2 ) / norm2_2;
1184         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( s * x2, s * y2 ) );
1185 }
1186
1187 RefCountPtr< const Lang::Value >
1188 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Coords2D ) arg2, const Kernel::PassedDyn & dyn ) const
1189 {
1190         const Concrete::Length x1 = arg1->x_.get( );
1191         const Concrete::Length y1 = arg1->y_.get( );
1192         const Concrete::Length x2 = arg2->x_.get( );
1193         const Concrete::Length y2 = arg2->y_.get( );
1194         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2;
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 ) / norm2_2;
1200         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( s * x2, s * y2 ) );
1201 }
1202
1203 RefCountPtr< const Lang::Value >
1204 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1205 {
1206         const double x1 = arg1->x_;
1207         const double y1 = arg1->y_;
1208         const double z1 = arg1->z_;
1209         const double x2 = arg2->x_;
1210         const double y2 = arg2->y_;
1211         const double z2 = arg2->z_;
1212         double norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1213         if( norm2_2 == 0 )
1214                 {
1215                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1216                 }
1217         double s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1218         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( s * x2, s * y2, s * z2 ) );
1219 }
1220
1221 RefCountPtr< const Lang::Value >
1222 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1223 {
1224         const double x1 = arg1->x_;
1225         const double y1 = arg1->y_;
1226         const double z1 = arg1->z_;
1227         const Concrete::Length x2 = arg2->x_.get( );
1228         const Concrete::Length y2 = arg2->y_.get( );
1229         const Concrete::Length z2 = arg2->z_.get( );
1230         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1231         if( norm2_2 == 0 )
1232                 {
1233                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1234                 }
1235         Physical< -1, 0 > s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1236         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( s * x2, s * y2, s * z2 ) );
1237 }
1238
1239 RefCountPtr< const Lang::Value >
1240 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::FloatTriple ) arg2, const Kernel::PassedDyn & dyn ) const
1241 {
1242         const Concrete::Length x1 = arg1->x_.get( );
1243         const Concrete::Length y1 = arg1->y_.get( );
1244         const Concrete::Length z1 = arg1->z_.get( );
1245         const double x2 = arg2->x_;
1246         const double y2 = arg2->y_;
1247         const double z2 = arg2->z_;
1248         const double norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1249         if( norm2_2 == 0 )
1250                 {
1251                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1252                 }
1253         Concrete::Length s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1254         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( s * x2, s * y2, s * z2 ) );
1255 }
1256
1257 RefCountPtr< const Lang::Value >
1258 Ast::ProjectionExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Coords3D ) arg2, const Kernel::PassedDyn & dyn ) const
1259 {
1260         const Concrete::Length x1 = arg1->x_.get( );
1261         const Concrete::Length y1 = arg1->y_.get( );
1262         const Concrete::Length z1 = arg1->z_.get( );
1263         const Concrete::Length x2 = arg2->x_.get( );
1264         const Concrete::Length y2 = arg2->y_.get( );
1265         const Concrete::Length z2 = arg2->z_.get( );
1266         Concrete::LengthSquared norm2_2 = x2 * x2 + y2 * y2 + z2 * z2;
1267         if( norm2_2 == 0 )
1268                 {
1269                         throw Exceptions::OutOfRange( expr2_->loc( ), strrefdup( "Projection on zero length vector." ) );
1270                 }
1271         double s = ( x1 * x2 + y1 * y2 + z1 * z2 ) / norm2_2;
1272         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( s * x2, s * y2, s * z2 ) );
1273 }
1274
1275
1276 RefCountPtr< const Lang::Value >
1277 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1278 {
1279         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ / arg2->val_ ) );
1280 }
1281
1282 RefCountPtr< const Lang::Value >
1283 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1284 {
1285         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->get( ) / arg2->get( ) ) );
1286 }
1287
1288 RefCountPtr< const Lang::Value >
1289 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1290 {
1291         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) / arg2->val_ ) );
1292 }
1293
1294 RefCountPtr< const Lang::Value >
1295 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::FloatPair ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1296 {
1297         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_ / arg2->val_, arg1->y_ / arg2->val_ ) );
1298 }
1299
1300 RefCountPtr< const Lang::Value >
1301 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1302 {
1303         return RefCountPtr< const Lang::Value >( new Lang::Coords2D( arg1->x_.get( ) / arg2->val_, arg1->y_.get( ) / arg2->val_ ) );
1304 }
1305
1306 RefCountPtr< const Lang::Value >
1307 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords2D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1308 {
1309         return RefCountPtr< const Lang::Value >( new Lang::FloatPair( arg1->x_.get( ) / arg2->get( ), arg1->y_.get( ) / arg2->get( ) ) );
1310 }
1311
1312 RefCountPtr< const Lang::Value >
1313 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::FloatTriple ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1314 {
1315         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_ / arg2->val_, arg1->y_ / arg2->val_, arg1->z_ / arg2->val_ ) );
1316 }
1317
1318 RefCountPtr< const Lang::Value >
1319 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Float ) arg2, const Kernel::PassedDyn & dyn ) const
1320 {
1321         return RefCountPtr< const Lang::Value >( new Lang::Coords3D( arg1->x_.get( ) / arg2->val_, arg1->y_.get( ) / arg2->val_, arg1->z_.get( ) / arg2->val_ ) );
1322 }
1323
1324 RefCountPtr< const Lang::Value >
1325 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Coords3D ) arg1, DUMMYANDREF( const Lang::Length ) arg2, const Kernel::PassedDyn & dyn ) const
1326 {
1327         return RefCountPtr< const Lang::Value >( new Lang::FloatTriple( arg1->x_.get( ) / arg2->get( ), arg1->y_.get( ) / arg2->get( ), arg1->z_.get( ) / arg2->get( ) ) );
1328 }
1329
1330 RefCountPtr< const Lang::Value >
1331 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Integer ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1332 {
1333         return RefCountPtr< const Lang::Value >( new Lang::Integer( arg1->val_ / arg2->val_ ) );
1334 }
1335
1336 RefCountPtr< const Lang::Value >
1337 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Float ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1338 {
1339         return RefCountPtr< const Lang::Value >( new Lang::Float( arg1->val_ / arg2->val_ ) );
1340 }
1341
1342 RefCountPtr< const Lang::Value >
1343 Ast::SlashExpr::impl( DUMMYANDREF( const Lang::Length ) arg1, DUMMYANDREF( const Lang::Integer ) arg2, const Kernel::PassedDyn & dyn ) const
1344 {
1345         return RefCountPtr< const Lang::Value >( new Lang::Length( arg1->get( ) / static_cast< double >( arg2->val_ ) ) );
1346 }
1347
1348
1349 RefCountPtr< const Lang::Value >
1350 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Transform2D ) arg1, DUMMYANDREF( const Lang::Transform2D ) arg2, const Kernel::PassedDyn & dyn ) const
1351 {
1352         return RefCountPtr< const Lang::Value >( new Lang::Transform2D( *arg1, *arg2 ) );
1353 }
1354
1355 RefCountPtr< const Lang::Value >
1356 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Transform3D ) arg1, DUMMYANDREF( const Lang::Transform3D ) arg2, const Kernel::PassedDyn & dyn ) const
1357 {
1358         return RefCountPtr< const Lang::Value >( new Lang::Transform3D( *arg1, *arg2 ) );
1359 }
1360
1361 RefCountPtr< const Lang::Value >
1362 Ast::ComposeExpr::impl( DUMMYANDREF( const Lang::Function ) arg1, DUMMYANDREF( const Lang::Function ) arg2, const Kernel::PassedDyn & dyn ) const
1363 {
1364         return RefCountPtr< const Lang::Value >( new Lang::ComposedFunction( arg1, arg2 ) );
1365 }