Changeset 284 for branches


Ignore:
Timestamp:
Dec 5, 2011 6:21:21 AM (7 years ago)
Author:
kulshres
Message:

Merge branch 'advector' of 'gitclone' into 'branches/advector'

The following commits have been merged:

commit 69df20b8f0240e80515c7f0df456f124cef70cf8
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Dec 5 11:32:58 2011 +0100

shift around some code and add another constructor

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit b2c13089d4f5b45e7626e04c17b2f7bee08adc6a
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Nov 29 17:29:47 2011 +0100

const no more needed after last bugfix

add check for gradient w.r.t. rhs vector.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 78ea1e83eb17163fa0703e7b2b289659c4c6d42b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Nov 28 17:13:23 2011 +0100

bugfix in reverse mode during ref_copyout

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 3a7c70061118c89ad66afeec45d957dbdaf002b3
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Nov 28 17:12:39 2011 +0100

Add one more assignment operator

this one is used when an adubref is copied into another adubref
as in from one advector to another advector, as this needs taping
however we don't need to override copy-constructor, because
construction can only be done when returning adubref.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 9c150d9aa825cf1e5964cd15c7d38b9a34984fce
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Nov 25 12:49:14 2011 +0100

changed aTmp*TRES to (aTmp==0)?0:(aTmp*TRES) and similar occurences to avoid nans by 0*inf

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit e076d0ab98331c4240c0318f1b555724e35235eb
Merge: 0efabbc 1861102
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Nov 25 12:34:08 2011 +0100

Merge branch 'master' into advector

commit 0efabbcb41d8b17f0fe55a35ca63ba93913bccbe
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Nov 25 12:32:36 2011 +0100

compile with -std=gnu99 to get both _GNU_SOURCE and _ISOC99_SOURCE

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 45fa79bd4d8ae0f4ef1e39b32f96271134e886f5
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Nov 25 12:20:02 2011 +0100

cast result of trunc to avoid warnings

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit b97ae47a80f7c0034b8f29d14656f75abcd51b4d
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Nov 24 17:53:11 2011 +0100

counting down with unsigned variables is dangerous

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 5dd6a95ce0403f9ac4b262a9546f86e95a5489ac
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Nov 24 17:52:40 2011 +0100

reverse the order of indep vars and add reverse call

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 2d794980215e1ae41af0e3cc6ed8a5e97507a2f7
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Nov 24 17:49:25 2011 +0100

Add functions to print L and R and compute scalar product

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 889d35f671f2d2eea4dda182b0d903746994fbcd
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Nov 24 17:47:31 2011 +0100

bugfixes in luexam

use less adoubles, loop variables for constant sized loops should
remain inactive size_t. counting down with size_t is bad.

const-ness of advectors matters during active subscripting,
espacially when the lhs is a subscripted advector too, unless
there is a expression involving badouble on the rhs.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 0dadd11bf743e7283a26613c1503778c6997654a
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Nov 23 17:18:05 2011 +0100

tweak the example a bit

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 898afff0d43d86941125dd2e71857c619e3f28a4
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Nov 23 17:17:43 2011 +0100

If location buffer must contain n+2 free spaces

in case location buffer goes onto disk then check and write that
block before doing a subscript operation
if location buffer is smaller than n+2 then we cannot continue.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 1c2e4771972f0ce4db38bd959c23d18c061be568
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Nov 23 15:38:50 2011 +0100

one more cast

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 71b506ae55f8d6754f5c2a1f800220cb5a5bb974
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Nov 23 15:27:53 2011 +0100

Compilation fixes for sparse configuration

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 73334f20d51e707ee709a3602060aa3351dc6c29
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Nov 22 18:23:37 2011 +0100

add an example that uses advector with permutations

Lu factorization with pivoting is implemented here. The same traced
procedure can be used for different matrices that require different
pivots.

Zos_forward has been verified, WIP to verify derivatives.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit c54da9e8cd03e99d9362cc1a7eb551101b5a4cb8
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Nov 22 18:20:35 2011 +0100

some more inline helpers for advector

the destructor need not contain anything.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit d403b2d2b7e591db7c353c8c3ce551e7d6174df0
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Nov 22 18:19:58 2011 +0100

implement condassign for adubref

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 696e18b5dcf9534f7609243f085a508fba178b6c
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Nov 22 18:19:09 2011 +0100

bugfix in -= operator for adubref

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit b7dd8285c6fe8262d07d0a5393c15bcca7eeae96
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Nov 21 13:47:48 2011 +0100

implement reference operations in forward and reverse mode

the referenced location is recorded in the taylor buffer of the
reference variable, and read from the taylor buffer before any
operation is performed. The operations are then performed directly
on the referenced location.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit d546c517676a42065a98df782898f9e3472836b2
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Nov 21 13:45:49 2011 +0100

add new operations for the tape to work with references

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 07508c193f53c6c5912485dcb517ca7c67b75234
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Nov 21 13:45:17 2011 +0100

Add a class to work as a reference to adouble and adub

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit a64a797bd2bbe0f9400e47661f304a33e39a216a
Merge: e60d733 ce4d803
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 9 17:57:41 2011 +0200

Merge branch 'master' into advector

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit e60d733c951a8a1d621a1401744fa03db78e9b92
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Mar 2 15:32:28 2011 +0100

introduce active subscript operation in forward and reverse

subscript operation as previously defined on advector was not quite
correct in case of computed index that changed while being evaluated
from tape. In this case we need the tape to record the subscript
operation so that the correct taylor and adjoint values are propagated
even if the index changed. This is especially true for index computation
via the lookupindex() function, where the index depends on the arguments
x and y which may change their values.

This active subscript is a copy_value operation not a copy_ref one.
So the result should not be used as an lvalue for any further operation.
In case the result is used as an lvalue the original entry in the
vector will not be altered, only the copied out version will be altered.

Also the safe mode of integer propagation for sparsity pattern
computation is not supported, only the tight mode is supported.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 5764beb91000483e02d4c6b52e67d177fff04a42
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Mar 2 13:59:12 2011 +0100

zeroing out the store is not necessary at all

and saves us some time by reducing memory access.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 29d3460e0c7a6d2839a25d8896c37fff98ad6a3c
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Mar 2 13:57:33 2011 +0100

oplate.h is not needed after installation

so don't install it, and don't make it public api. it is totally
internal to ADOL-C itself.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 0e3ac08ba9c6ac0aa7d3820def9e62e079a83e44
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Mar 1 16:00:17 2011 +0100

add missing include

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit b7364c7c2164981ce9e198b69f6aef8684388b43
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Mar 1 15:46:56 2011 +0100

Add new files to buildsystem.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit aaefbdef3a6e00792ce0c57acff67e4f4ee3224b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Mar 1 15:38:59 2011 +0100

New class advector for index lookup and subscripting

This is a container using std::vector<adouble>. The subscripting
operations return references to adoubles, nothing needs to be written
onto the tape for this since the following operation using the adouble
reference will do the right thing.
The index lookup operation uses a sequence of n condassign_s ops which
are taped, and returns the index which matches the requirement as another
adouble.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

Location:
branches/advector
Files:
9 added
19 edited

Legend:

Unmodified
Added
Removed
  • branches/advector/ADOL-C/examples/Makefile.am

    r171 r284  
    3636
    3737if DOCEXA
    38 noinst_PROGRAMS         = detexam speelpenning powexam odexam \
     38noinst_PROGRAMS         = detexam speelpenning powexam odexam luexam \
    3939                          tapeless_scalar tapeless_vector
    4040endif
     
    4848odexam_SOURCES          = odexam.cpp
    4949
     50luexam_SOURCES          = luexam.cpp
     51
    5052tapeless_scalar_SOURCES = tapeless_scalar.cpp
    5153
  • branches/advector/ADOL-C/examples/Makefile.in

    r249 r284  
    3939host_triplet = @host@
    4040@DOCEXA_TRUE@noinst_PROGRAMS = detexam$(EXEEXT) speelpenning$(EXEEXT) \
    41 @DOCEXA_TRUE@   powexam$(EXEEXT) odexam$(EXEEXT) \
     41@DOCEXA_TRUE@   powexam$(EXEEXT) odexam$(EXEEXT) luexam$(EXEEXT) \
    4242@DOCEXA_TRUE@   tapeless_scalar$(EXEEXT) tapeless_vector$(EXEEXT)
    4343subdir = ADOL-C/examples
     
    5858detexam_LDADD = $(LDADD)
    5959detexam_DEPENDENCIES =
     60am_luexam_OBJECTS = luexam.$(OBJEXT)
     61luexam_OBJECTS = $(am_luexam_OBJECTS)
     62luexam_LDADD = $(LDADD)
     63luexam_DEPENDENCIES =
    6064am_odexam_OBJECTS = odexam.$(OBJEXT)
    6165odexam_OBJECTS = $(am_odexam_OBJECTS)
     
    8892        --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \
    8993        $(LDFLAGS) -o $@
    90 SOURCES = $(detexam_SOURCES) $(odexam_SOURCES) $(powexam_SOURCES) \
    91         $(speelpenning_SOURCES) $(tapeless_scalar_SOURCES) \
    92         $(tapeless_vector_SOURCES)
    93 DIST_SOURCES = $(detexam_SOURCES) $(odexam_SOURCES) $(powexam_SOURCES) \
    94         $(speelpenning_SOURCES) $(tapeless_scalar_SOURCES) \
    95         $(tapeless_vector_SOURCES)
     94SOURCES = $(detexam_SOURCES) $(luexam_SOURCES) $(odexam_SOURCES) \
     95        $(powexam_SOURCES) $(speelpenning_SOURCES) \
     96        $(tapeless_scalar_SOURCES) $(tapeless_vector_SOURCES)
     97DIST_SOURCES = $(detexam_SOURCES) $(luexam_SOURCES) $(odexam_SOURCES) \
     98        $(powexam_SOURCES) $(speelpenning_SOURCES) \
     99        $(tapeless_scalar_SOURCES) $(tapeless_vector_SOURCES)
    96100RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
    97101        html-recursive info-recursive install-data-recursive \
     
    292296powexam_SOURCES = powexam.cpp
    293297odexam_SOURCES = odexam.cpp
     298luexam_SOURCES = luexam.cpp
    294299tapeless_scalar_SOURCES = tapeless_scalar.cpp
    295300tapeless_vector_SOURCES = tapeless_vector.cpp
     
    340345        @rm -f detexam$(EXEEXT)
    341346        $(CXXLINK) $(detexam_OBJECTS) $(detexam_LDADD) $(LIBS)
     347luexam$(EXEEXT): $(luexam_OBJECTS) $(luexam_DEPENDENCIES)
     348        @rm -f luexam$(EXEEXT)
     349        $(CXXLINK) $(luexam_OBJECTS) $(luexam_LDADD) $(LIBS)
    342350odexam$(EXEEXT): $(odexam_OBJECTS) $(odexam_DEPENDENCIES)
    343351        @rm -f odexam$(EXEEXT)
     
    363371
    364372@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/detexam.Po@am__quote@
     373@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/luexam.Po@am__quote@
    365374@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/odexam.Po@am__quote@
    366375@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/powexam.Po@am__quote@
  • branches/advector/ADOL-C/src/Makefile.am

    r272 r284  
    1212
    1313if SPARSE
    14 AM_CFLAGS            = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -DSPARSE=1
     14AM_CFLAGS            = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -DSPARSE=1 -std=gnu99
    1515AM_CXXFLAGS          = @ac_adolc_cxxflags@ -DADOLC_INTERNAL=1 -DSPARSE=1
    1616else
    17 AM_CFLAGS            = @ac_adolc_cflags@ -DADOLC_INTERNAL=1
     17AM_CFLAGS            = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -std=gnu99
    1818AM_CXXFLAGS          = @ac_adolc_cxxflags@ -DADOLC_INTERNAL=1
    1919endif
     
    3232
    3333EXTRA_DIST           = uni5_for.c fo_rev.c ho_rev.c \
    34                        taping_p.h malloc.h storemanager.h \
     34                       oplate.h taping_p.h malloc.h storemanager.h \
    3535                       externfcts_p.h checkpointing_p.h buffer_temp.h
    3636
    3737pkginclude_HEADERS   = adolc.h adalloc.h adouble.h adutils.h adutilsc.h \
    3838                       common.h convolut.h dvlparms.h fortutils.h\
    39                        interfaces.h oplate.h taping.h usrparms.h \
     39                       interfaces.h taping.h usrparms.h \
    4040                       externfcts.h checkpointing.h fixpoint.h\
    4141                       adolc_sparse.h adolc_openmp.h \
    42                        revolve.h
     42                       revolve.h advector.h
    4343
    4444lib_LTLIBRARIES      = libadolc.la
     
    6161                       indopro_forward_s.c indopro_forward_t.c \
    6262                       nonl_ind_forward_s.c nonl_ind_forward_t.c \
    63                        int_reverse_s.c int_reverse_t.c
     63                       int_reverse_s.c int_reverse_t.c advector.cpp
    6464
    6565libadolc_la_LIBADD   = drivers/libdrivers.la sparse/libsparse.la \
     
    7777                       forward_partx.c \
    7878                       externfcts.cpp checkpointing.cpp \
    79                        fixpoint.cpp fov_offset_forward.c revolve.c
     79                       fixpoint.cpp fov_offset_forward.c revolve.c advector.cpp
    8080
    8181libadolc_la_LIBADD   = drivers/libdrivers.la tapedoc/libtapedoc.la
  • branches/advector/ADOL-C/src/Makefile.in

    r272 r284  
    8686        fov_reverse.c hos_reverse.c hos_ov_reverse.c hov_reverse.c \
    8787        forward_partx.c externfcts.cpp checkpointing.cpp fixpoint.cpp \
    88         fov_offset_forward.c revolve.c taping_p.h int_forward_s.c \
    89         int_forward_t.c indopro_forward_s.c indopro_forward_t.c \
    90         nonl_ind_forward_s.c nonl_ind_forward_t.c int_reverse_s.c \
    91         int_reverse_t.c
     88        fov_offset_forward.c revolve.c advector.cpp taping_p.h \
     89        int_forward_s.c int_forward_t.c indopro_forward_s.c \
     90        indopro_forward_t.c nonl_ind_forward_s.c nonl_ind_forward_t.c \
     91        int_reverse_s.c int_reverse_t.c
    9292@SPARSE_FALSE@am_libadolc_la_OBJECTS = adalloc.lo malloc.lo adouble.lo \
    9393@SPARSE_FALSE@  convolut.lo fortutils.lo interfaces.lo \
     
    9898@SPARSE_FALSE@  hos_ov_reverse.lo hov_reverse.lo \
    9999@SPARSE_FALSE@  forward_partx.lo externfcts.lo checkpointing.lo \
    100 @SPARSE_FALSE@  fixpoint.lo fov_offset_forward.lo revolve.lo
     100@SPARSE_FALSE@  fixpoint.lo fov_offset_forward.lo revolve.lo \
     101@SPARSE_FALSE@  advector.lo
    101102@SPARSE_TRUE@am_libadolc_la_OBJECTS = adalloc.lo malloc.lo adouble.lo \
    102103@SPARSE_TRUE@   convolut.lo fortutils.lo interfaces.lo \
     
    111112@SPARSE_TRUE@   indopro_forward_t.lo nonl_ind_forward_s.lo \
    112113@SPARSE_TRUE@   nonl_ind_forward_t.lo int_reverse_s.lo \
    113 @SPARSE_TRUE@   int_reverse_t.lo
     114@SPARSE_TRUE@   int_reverse_t.lo advector.lo
    114115libadolc_la_OBJECTS = $(am_libadolc_la_OBJECTS)
    115116libadolc_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \
     
    315316top_builddir = @top_builddir@
    316317top_srcdir = @top_srcdir@
    317 @SPARSE_FALSE@AM_CFLAGS = @ac_adolc_cflags@ -DADOLC_INTERNAL=1
    318 @SPARSE_TRUE@AM_CFLAGS = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -DSPARSE=1
     318@SPARSE_FALSE@AM_CFLAGS = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -std=gnu99
     319@SPARSE_TRUE@AM_CFLAGS = @ac_adolc_cflags@ -DADOLC_INTERNAL=1 -DSPARSE=1 -std=gnu99
    319320@SPARSE_FALSE@AM_CXXFLAGS = @ac_adolc_cxxflags@ -DADOLC_INTERNAL=1
    320321@SPARSE_TRUE@AM_CXXFLAGS = @ac_adolc_cxxflags@ -DADOLC_INTERNAL=1 -DSPARSE=1
     
    325326MAINTAINERCLEANFILES = Makefile.in *~ *.orig adolc_config.h config.h.in
    326327EXTRA_DIST = uni5_for.c fo_rev.c ho_rev.c \
    327                        taping_p.h malloc.h storemanager.h \
     328                       oplate.h taping_p.h malloc.h storemanager.h \
    328329                       externfcts_p.h checkpointing_p.h buffer_temp.h
    329330
    330331pkginclude_HEADERS = adolc.h adalloc.h adouble.h adutils.h adutilsc.h \
    331332                       common.h convolut.h dvlparms.h fortutils.h\
    332                        interfaces.h oplate.h taping.h usrparms.h \
     333                       interfaces.h taping.h usrparms.h \
    333334                       externfcts.h checkpointing.h fixpoint.h\
    334335                       adolc_sparse.h adolc_openmp.h \
    335                        revolve.h
     336                       revolve.h advector.h
    336337
    337338lib_LTLIBRARIES = libadolc.la
     
    348349@SPARSE_FALSE@                       forward_partx.c \
    349350@SPARSE_FALSE@                       externfcts.cpp checkpointing.cpp \
    350 @SPARSE_FALSE@                       fixpoint.cpp fov_offset_forward.c revolve.c
     351@SPARSE_FALSE@                       fixpoint.cpp fov_offset_forward.c revolve.c advector.cpp
    351352
    352353@SPARSE_TRUE@libadolc_la_SOURCES = adalloc.c malloc.c adouble.cpp \
     
    364365@SPARSE_TRUE@                       indopro_forward_s.c indopro_forward_t.c \
    365366@SPARSE_TRUE@                       nonl_ind_forward_s.c nonl_ind_forward_t.c \
    366 @SPARSE_TRUE@                       int_reverse_s.c int_reverse_t.c
     367@SPARSE_TRUE@                       int_reverse_s.c int_reverse_t.c advector.cpp
    367368
    368369@SPARSE_FALSE@libadolc_la_LIBADD = drivers/libdrivers.la tapedoc/libtapedoc.la
     
    464465@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/adalloc.Plo@am__quote@
    465466@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/adouble.Plo@am__quote@
     467@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/advector.Plo@am__quote@
    466468@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkpointing.Plo@am__quote@
    467469@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/convolut.Plo@am__quote@
  • branches/advector/ADOL-C/src/adouble.cpp

    r275 r284  
    2222
    2323#include <adolc/adouble.h>
    24 #include <adolc/oplate.h>
     24#include "oplate.h"
    2525#include "taping_p.h"
    2626
     
    13581358    /* y+0.0 is a hack since condassign is currently not defined for
    13591359       badoubles */
    1360     condassign( sy,  y+0.0,  1.0 , -1.0 );
    1361     condassign( a1,  x+0.0, (adouble) atan(y/x),
    1362                 (adouble)( atan(y/x)+sy*2*pihalf));
    1363     condassign( a2,  (adouble) fabs(y), (adouble) (sy*pihalf-atan(x/y)),
    1364                 (adouble) 0.0 );
    1365     condassign( ret, (adouble) (fabs(x) - fabs(y)), a1, a2 );
     1360    condassign( sy,  y,  (adouble)1.0 , (adouble)-1.0 );
     1361    condassign( a1,  x,  atan(y/x),  atan(y/x)+sy*2*pihalf);
     1362    condassign( a2,  fabs(y), sy*pihalf-atan(x/y), (adouble) 0.0 );
     1363    condassign( ret, fabs(x) - fabs(y), a1, a2 );
    13661364    return ret;
    13671365}
     
    14001398    }
    14011399
    1402     condassign (ret, coval, exp(y*ADOLC_MATH_NSP::log(coval)),
    1403             ADOLC_MATH_NSP::pow(coval,y.getValue()) );
     1400    condassign (ret, (adouble) coval, exp(y*ADOLC_MATH_NSP::log(coval)),
     1401                (adouble) ADOLC_MATH_NSP::pow(coval,y.getValue()) );
    14041402
    14051403    return ret;
     
    14191417            fprintf(DIAG_OUT,"\nADOL-C message: negative exponent and zero basis deactivated\n");
    14201418    }
    1421     condassign(a1,-y, ADOLC_MATH_NSP::pow(vx,vy), pow(x,vy));
    1422     condassign(a2, fabs(x), pow(x, vy),a1);
    1423     condassign(ret,x+0.0, exp(y*log(x)),a2);
     1419    condassign(a1, -y, (adouble) ADOLC_MATH_NSP::pow(vx,vy), pow(x,vy));
     1420    condassign(a2, fabs(x), pow(x, vy), a1);
     1421    condassign(ret, x, exp(y*log(x)),a2);
    14241422
    14251423    return ret;
     
    17771775
    17781776/*--------------------------------------------------------------------------*/
    1779 void condassign( adouble &res,        const adouble &cond,
    1780                  const adouble &arg1, const adouble &arg2 ) {
     1777void condassign( adouble &res,         const badouble &cond,
     1778                 const badouble &arg1, const badouble &arg2 ) {
    17811779    ADOLC_OPENMP_THREAD_NUMBER;
    17821780    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    18021800
    18031801/*--------------------------------------------------------------------------*/
    1804 void condassign( adouble &res, const adouble &cond, const adouble &arg ) {
     1802void condassign( adouble &res, const badouble &cond, const badouble &arg ) {
    18051803    ADOLC_OPENMP_THREAD_NUMBER;
    18061804    ADOLC_OPENMP_GET_THREAD_NUMBER;
  • branches/advector/ADOL-C/src/adouble.h

    r207 r284  
    6060class adub;
    6161class badouble;
    62 class adubv;
    63 /* class doublev;  that's history */
    6462
    6563/*--------------------------------------------------------------------------*/
     
    8785*/
    8886class ADOLC_DLL_EXPORT badouble {
    89     friend ADOLC_DLL_EXPORT class badoublev;
    9087protected:
    9188    locint location;
     
    9592    //
    9693    // badouble( const badouble& a ) {location = a.location;};
    97     badouble( locint lo ) {
     94    explicit badouble( locint lo ) {
    9895        location = lo;
    9996    };
     
    117114    badouble& operator = ( const adub& );
    118115    double getValue() const;
    119     inline double value() {
     116    inline double value() const {
    120117        return getValue();
    121118    }
     
    235232    /*--------------------------------------------------------------------------*/
    236233    /* Conditionals */
    237     friend ADOLC_DLL_EXPORT void condassign( adouble &res, const adouble &cond,
    238             const adouble &arg1, const adouble &arg2 );
    239     friend ADOLC_DLL_EXPORT void condassign( adouble &res, const adouble &cond,
    240             const adouble &arg );
     234    friend ADOLC_DLL_EXPORT void condassign( adouble &res, const badouble &cond,
     235            const badouble &arg1, const badouble &arg2 );
     236    friend ADOLC_DLL_EXPORT void condassign( adouble &res, const badouble &cond,
     237            const badouble &arg );
    241238};
    242239
     
    256253class ADOLC_DLL_EXPORT adub:public badouble {
    257254    friend ADOLC_DLL_EXPORT class adouble;
     255    friend ADOLC_DLL_EXPORT class advector;
     256    friend ADOLC_DLL_EXPORT class adubref;
    258257#if GCC_VERSION >= 4003
    259258    adub( adub const &) {}
     
    266265        exit(-2);
    267266    };
    268     adub( double ):badouble(0) {
     267    explicit adub( double ):badouble(0) {
    269268        fprintf(DIAG_OUT,"ADOL-C error: illegal  construction of adub variable"
    270269                " from double\n");
     
    351350*/
    352351class ADOLC_DLL_EXPORT adouble:public badouble {
     352    friend ADOLC_DLL_EXPORT class advector;
    353353public:
    354354    adouble( const adub& );
  • branches/advector/ADOL-C/src/checkpointing.cpp

    r197 r284  
    1313---------------------------------------------------------------------------*/
    1414
    15 #include <adolc/oplate.h>
     15#include "oplate.h"
    1616#include <adolc/adalloc.h>
    1717#include "taping_p.h"
  • branches/advector/ADOL-C/src/externfcts.cpp

    r197 r284  
    1717#include "taping_p.h"
    1818#include <adolc/adouble.h>
    19 #include <adolc/oplate.h>
     19#include "oplate.h"
    2020#include "buffer_temp.h"
    2121
  • branches/advector/ADOL-C/src/fo_rev.c

    r277 r284  
    1717
    1818 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    19                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
    20  
     19               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     20               Kshitij Kulshreshtha
     21
    2122 This file is part of ADOL-C. This software is provided as open source.
    2223 Any use, reproduction, or distribution of the software constitutes
     
    189190#include <adolc/interfaces.h>
    190191#include <adolc/adalloc.h>
    191 #include <adolc/oplate.h>
     192#include "oplate.h"
    192193#include "taping_p.h"
    193194#include <adolc/externfcts.h>
     
    16641665#endif /* !_NTIGHT_ */
    16651666                break;
     1667
     1668                /*--------------------------------------------------------------------------*/
     1669            case subscript:
     1670                {
     1671                    double val = get_val_r();
     1672                    size_t cnt, idx, numval = (size_t)trunc(fabs(val));
     1673                    if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= numval + 2) {
     1674                        fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],numval);
     1675                        exit(-2);
     1676                    }
     1677                    locint vectorloc[numval];
     1678                    for (cnt = 1; cnt <= numval; cnt++)
     1679                        vectorloc[numval - cnt] = get_locint_r();
     1680                    res = get_locint_r();
     1681                    arg = get_locint_r();
     1682#if !defined(_NTIGHT_)
     1683                    idx = (size_t)trunc(fabs(TARG));
     1684                    arg1 = vectorloc[idx];
     1685                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     1686                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1687                    FOR_0_LE_l_LT_p
     1688                    {
     1689#if defined(_INT_REV_)
     1690                        AARG1_INC |= ARES;
     1691                        ARES_INC = 0;
     1692#else
     1693                        AARG1_INC += ARES;
     1694                        ARES = 0.0;
     1695#endif
     1696                    }
     1697                    ADOLC_GET_TAYLOR(res);
     1698#else
     1699                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
     1700                    exit(-2);
     1701#endif /* !_NTIGHT_ */
     1702                }
     1703                break;
     1704
     1705            case subscript_ref:
     1706                {
     1707                    double val = get_val_r();
     1708                    size_t cnt, idx, numval = (size_t)trunc(fabs(val));
     1709                    if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= numval + 2) {
     1710                        fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],numval);
     1711                        exit(-2);
     1712                    }
     1713                    locint vectorloc[numval];
     1714                    for (cnt = 1; cnt <= numval; cnt++)
     1715                        vectorloc[numval - cnt] = get_locint_r();
     1716                    res = get_locint_r();
     1717                    arg = get_locint_r();
     1718#if !defined(_NTIGHT_)
     1719                    idx = (size_t)trunc(fabs(TARG));
     1720                    arg1 = (size_t)trunc(fabs(TRES));
     1721                    // This is actually NOP
     1722                    // basically all we need is that arg1 == vectorloc[idx]
     1723                    // so doing a check here is probably good
     1724                    if (arg1 != vectorloc[idx]) {
     1725                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %d, referenced = %d\n", vectorloc[idx], arg1);
     1726                        exit(-2);
     1727                    }
     1728                    ADOLC_GET_TAYLOR(res);
     1729#else
     1730                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
     1731                    exit(-2);
     1732#endif /* !_NTIGHT_ */
     1733                }
     1734                break;
     1735
     1736            case ref_copyout:
     1737                res = get_locint_r();
     1738                arg1 = get_locint_r();
     1739#if !defined(_NTIGHT_)
     1740                arg = (size_t)trunc(fabs(TARG1));
     1741                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1742                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1743               
     1744                FOR_0_LE_l_LT_p
     1745                {
     1746#if defined(_INT_REV_)                 
     1747                  AARG_INC |= ARES;
     1748                  ARES_INC = 0;
     1749#else
     1750                  AARG_INC += ARES;
     1751                  ARES_INC = 0.0;
     1752#endif
     1753                }
     1754                ADOLC_GET_TAYLOR(res);
     1755#else
     1756                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1757                exit(-2);
     1758#endif
     1759                break;
     1760
     1761
     1762            case ref_incr_a:                        /* Increment an adouble    incr_a */
     1763            case ref_decr_a:                        /* Increment an adouble    decr_a */
     1764                arg1   = get_locint_r();
     1765
     1766#if !defined(_NTIGHT_)
     1767                res = (size_t)trunc(fabs(TARG1));
     1768                ADOLC_GET_TAYLOR(res);
     1769#else
     1770                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1771                exit(-2);
     1772#endif /* !_NTIGHT_ */
     1773                break;
     1774
     1775            case ref_assign_d:            /* assign an adouble variable a    assign_d */
     1776                /* double value. (=) */
     1777                arg1   = get_locint_r();
     1778#if !defined(_NTIGHT_)
     1779                res = (size_t)trunc(fabs(TARG1));
     1780                coval = get_val_r();
     1781
     1782                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1783
     1784                FOR_0_LE_l_LT_p
     1785#if defined(_INT_REV_)                 
     1786                ARES_INC = 0;
     1787#else
     1788                ARES_INC = 0.0;
     1789#endif
     1790
     1791                ADOLC_GET_TAYLOR(res);
     1792#else
     1793                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1794                exit(-2);
     1795#endif /* !_NTIGHT_ */
     1796                break;
     1797
     1798            case ref_assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
     1799            case ref_assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
     1800                arg1 = get_locint_r();
     1801
     1802#if !defined(_NTIGHT_)
     1803                res = (size_t)trunc(fabs(TARG1));
     1804
     1805                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1806
     1807                FOR_0_LE_l_LT_p
     1808#if defined(_INT_REV_)                 
     1809                ARES_INC = 0;
     1810#else
     1811                ARES_INC = 0.0;
     1812#endif
     1813                ADOLC_GET_TAYLOR(res);
     1814#else
     1815                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1816                exit(-2);
     1817#endif /* !_NTIGHT_ */
     1818                break;
     1819
     1820            case ref_assign_a:           /* assign an adouble variable an    assign_a */
     1821                /* adouble value. (=) */
     1822                arg1 = get_locint_r();
     1823                arg = get_locint_r();
     1824
     1825#if !defined(_NTIGHT_)
     1826                res = (size_t)trunc(fabs(TARG1));
     1827
     1828                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1829                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1830
     1831                FOR_0_LE_l_LT_p
     1832                {
     1833#if defined(_INT_REV_)                 
     1834                  AARG_INC |= ARES;
     1835                  ARES_INC = 0;
     1836#else
     1837                  AARG_INC += ARES;
     1838                  ARES_INC = 0.0;
     1839#endif
     1840                }
     1841
     1842                ADOLC_GET_TAYLOR(res);
     1843#else
     1844                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1845                exit(-2);
     1846#endif /* !_NTIGHT_ */
     1847                break;
     1848
     1849            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
     1850                /* independent double value (<<=) */
     1851                arg1 = get_locint_r();
     1852
     1853#if !defined(_NTIGHT_)
     1854                res = (size_t)trunc(fabs(TARG1));
     1855
     1856                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1857
     1858                FOR_0_LE_l_LT_p
     1859                    RESULTS(l,indexi) = ARES_INC;
     1860
     1861                ADOLC_GET_TAYLOR(res);
     1862#else
     1863                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1864                exit(-2);
     1865#endif /* !_NTIGHT_ */
     1866                indexi--;
     1867                break;
     1868
     1869            case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
     1870                /* adouble. (+=) */
     1871                arg1   = get_locint_r();
     1872#if !defined(_NTIGHT_)
     1873                res = (size_t)trunc(fabs(TARG1));
     1874                coval = get_val_r();
     1875
     1876                ADOLC_GET_TAYLOR(res);
     1877#else
     1878                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1879                exit(-2);
     1880#endif /* !_NTIGHT_ */
     1881                break;
     1882
     1883            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
     1884                /* adouble. (+=) */
     1885                arg1 = get_locint_r();
     1886                arg = get_locint_r();
     1887
     1888#if !defined(_NTIGHT_)
     1889                res = (size_t)trunc(fabs(TARG1));
     1890
     1891                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1892                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
     1893
     1894                FOR_0_LE_l_LT_p
     1895#if defined(_INT_REV_)
     1896                AARG_INC |= ARES_INC;
     1897#else
     1898                AARG_INC += ARES_INC;
     1899#endif
     1900
     1901                ADOLC_GET_TAYLOR(res);
     1902#else
     1903                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1904                exit(-2);
     1905#endif /* !_NTIGHT_ */
     1906                break;
     1907
     1908            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
     1909                /* adouble. (-=) */
     1910                arg1   = get_locint_r();
     1911#if !defined(_NTIGHT_)
     1912                res = (size_t)trunc(fabs(TARG1));
     1913                coval = get_val_r();
     1914
     1915                ADOLC_GET_TAYLOR(res);
     1916#else
     1917                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1918                exit(-2);
     1919#endif /* !_NTIGHT_ */
     1920               break;
     1921
     1922            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
     1923                /* adouble. (-=) */
     1924                arg1 = get_locint_r();
     1925                arg = get_locint_r();
     1926
     1927#if !defined(_NTIGHT_)
     1928                res = (size_t)trunc(fabs(TARG1));
     1929                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1930                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1931
     1932                FOR_0_LE_l_LT_p
     1933#if defined(_INT_REV_)
     1934                AARG_INC |= ARES_INC;
     1935#else
     1936                AARG_INC -= ARES_INC;
     1937#endif
     1938
     1939               ADOLC_GET_TAYLOR(res);
     1940#else
     1941                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1942                exit(-2);
     1943#endif /* !_NTIGHT_ */
     1944                break;
     1945
     1946            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
     1947                /* flaoting point. (*=) */
     1948                arg1   = get_locint_r();
     1949#if !defined(_NTIGHT_)
     1950                res = (size_t)trunc(fabs(TARG1));
     1951                coval = get_val_r();
     1952
     1953#if !defined(_INT_REV_)
     1954                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1955
     1956                FOR_0_LE_l_LT_p
     1957                ARES_INC *= coval;
     1958#endif
     1959
     1960                ADOLC_GET_TAYLOR(res);
     1961#else
     1962                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1963                exit(-2);
     1964#endif /* !_NTIGHT_ */
     1965                break;
     1966
     1967            case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
     1968                /* (*=) */
     1969                arg1 = get_locint_r();
     1970                arg = get_locint_r();
     1971
     1972#if !defined(_NTIGHT_)
     1973                res = (size_t)trunc(fabs(TARG1));
     1974                ADOLC_GET_TAYLOR(res);
     1975
     1976                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1977                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1978
     1979                FOR_0_LE_l_LT_p
     1980#if defined(_INT_REV_)
     1981                AARG_INC |= ARES_INC;
     1982#else
     1983                { aTmp = ARES;
     1984                  /* olvo 980713 nn: ARES = 0.0; */
     1985                    ARES_INC =  (aTmp==0)?0:(aTmp * TARG);
     1986                    AARG_INC += (aTmp==0)?0:(aTmp * TRES);
     1987                }
     1988#endif     
     1989#else
     1990                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     1991                exit(-2);
     1992#endif /* !_NTIGHT_ */
     1993                break;
     1994
     1995        case ref_cond_assign:                                      /* cond_assign */
     1996           {
     1997                locint ref    = get_locint_r();
     1998                arg2   = get_locint_r();
     1999                arg1   = get_locint_r();
     2000                arg    = get_locint_r();
     2001#if !defined(_NTIGHT_)
     2002                coval  = get_val_r();
     2003                res = (size_t)trunc(fabs(rp_T[ref]));
     2004
     2005                ADOLC_GET_TAYLOR(res);
     2006
     2007                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2008                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2009                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
     2010
     2011                /* olvo 980924 changed code a little bit */
     2012                if (TARG > 0.0) {
     2013                    if (res != arg1)
     2014                        FOR_0_LE_l_LT_p
     2015                        { if ((coval <= 0.0) && (ARES))
     2016                          MINDEC(ret_c,2);
     2017#if defined(_INT_REV_)
     2018                              AARG1_INC |= ARES;
     2019                              ARES_INC = 0;
     2020#else
     2021                          AARG1_INC += ARES;
     2022                          ARES_INC = 0.0;
     2023#endif
     2024                        } else
     2025                            FOR_0_LE_l_LT_p
     2026                            if ((coval <= 0.0) && (ARES_INC))
     2027                                    MINDEC(ret_c,2);
     2028                } else {
     2029                    if (res != arg2)
     2030                        FOR_0_LE_l_LT_p
     2031                        { if ((coval <= 0.0) && (ARES))
     2032                          MINDEC(ret_c,2);
     2033#if defined(_INT_REV_)
     2034                          AARG2_INC |= ARES;
     2035                          ARES_INC = 0;
     2036#else
     2037                          AARG2_INC += ARES;
     2038                          ARES_INC = 0.0;
     2039#endif
     2040                        } else
     2041                            FOR_0_LE_l_LT_p
     2042                            if ((coval <= 0.0) && (ARES_INC))
     2043                                    MINDEC(ret_c,2);
     2044                }
     2045#else
     2046                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2047                exit(-2);
     2048#endif /* !_NTIGHT_ */
     2049                }
     2050                break;
     2051
     2052            case ref_cond_assign_s:                                  /* cond_assign_s */
     2053                arg2   = get_locint_r();
     2054                arg1  = get_locint_r();
     2055                arg   = get_locint_r();
     2056#if !defined(_NTIGHT_)
     2057                coval = get_val_r();
     2058                res = (size_t)trunc(fabs(TARG2));
     2059                ADOLC_GET_TAYLOR(res);
     2060
     2061                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2062                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2063
     2064                /* olvo 980924 changed code a little bit */
     2065                if (TARG > 0.0) {
     2066                    if (res != arg1)
     2067                        FOR_0_LE_l_LT_p
     2068                        { if ((coval <= 0.0) && (ARES))
     2069                          MINDEC(ret_c,2);
     2070#if defined(_INT_REV_)
     2071                          AARG1_INC |= ARES;
     2072                          ARES_INC = 0.0;
     2073#else
     2074                          AARG1_INC += ARES;
     2075                          ARES_INC = 0.0;
     2076#endif
     2077                        } else
     2078                            FOR_0_LE_l_LT_p
     2079                            if ((coval <= 0.0) && (ARES_INC))
     2080                                    MINDEC(ret_c,2);
     2081                } else
     2082                    if (TARG == 0.0) /* we are at the tie */
     2083                        FOR_0_LE_l_LT_p
     2084                        if (ARES_INC)
     2085                            MINDEC(ret_c,0);
     2086#else
     2087                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2088                exit(-2);
     2089#endif /* !_NTIGHT_ */
     2090                break;
     2091
    16662092
    16672093                /****************************************************************************/
  • branches/advector/ADOL-C/src/ho_rev.c

    r249 r284  
    1212 
    1313 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    14                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
    15  
     14               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     15               Kshitij Kulshreshtha
     16
    1617 This file is part of ADOL-C. This software is provided as open source.
    1718 Any use, reproduction, or distribution of the software constitutes
     
    267268#include <adolc/interfaces.h>
    268269#include <adolc/adalloc.h>
    269 #include <adolc/oplate.h>
     270#include "oplate.h"
    270271#include "taping_p.h"
    271272#include <adolc/convolut.h>
     
    20402041            break;
    20412042
     2043                /*--------------------------------------------------------------------------*/
     2044            case subscript:
     2045                coval = get_val_r();
     2046                if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= coval + 2) {
     2047                    fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],coval);
     2048                        exit(-2);
     2049                    }
     2050                {
     2051                    size_t cnt, idx, numval = (size_t)trunc(fabs(coval));
     2052                    locint vectorloc[numval];
     2053                    for (cnt = 1; cnt <= numval; cnt++)
     2054                        vectorloc[numval - cnt] = get_locint_r();
     2055                    res = get_locint_r();
     2056                    arg = get_locint_r();
     2057                    ASSIGN_T(Targ, rpp_T[arg])
     2058                    idx = (size_t)trunc(fabs(TARG));
     2059                    arg1 = vectorloc[idx];
     2060                    ASSIGN_A(Aarg1, rpp_A[arg1])
     2061                    ASSIGN_A(Ares, rpp_A[res])
     2062
     2063                    FOR_0_LE_l_LT_p
     2064                    if (0 == ARES) {
     2065                        HOV_INC(Aarg1, k1)
     2066                        HOV_INC(Ares, k1)
     2067                    } else {
     2068                        MAXDEC(AARG1,ARES);
     2069                        AARG1_INC_O;
     2070                        ARES_INC = 0.0;
     2071                        FOR_0_LE_i_LT_k
     2072                        {
     2073                            AARG1_INC += ARES;
     2074                            ARES_INC = 0.0;
     2075                        }
     2076                    }
     2077                    GET_TAYL(res,k,p)
     2078                }
     2079                break;
     2080
     2081            case subscript_ref:
     2082                coval = get_val_r();
     2083                if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= coval + 2) {
     2084                    fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],coval);
     2085                    exit(-2);
     2086                }
     2087                {
     2088                    size_t cnt, idx, numval = (size_t)trunc(fabs(coval));
     2089                    locint vectorloc[numval];
     2090                    for (cnt = 1; cnt <= numval; cnt++)
     2091                        vectorloc[numval - cnt] = get_locint_r();
     2092                    res = get_locint_r();
     2093                    arg = get_locint_r();
     2094                    ASSIGN_T(Targ, rpp_T[arg])
     2095                    ASSIGN_T(Tres, rpp_T[res])
     2096                    idx = (size_t)trunc(fabs(TARG));
     2097                    arg1 = (size_t)trunc(fabs(TRES));
     2098                    // This is actually NOP
     2099                    // basically all we need is that arg1 == vectorloc[idx]
     2100                    // so doing a check here is probably good
     2101                    if (arg1 != vectorloc[idx]) {
     2102                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %d, referenced = %d\n", vectorloc[idx], arg1);
     2103                        exit(-2);
     2104                    }
     2105                    GET_TAYL(res,k,p)
     2106                }
     2107                break;
     2108
     2109            case ref_copyout:
     2110                res = get_locint_r();
     2111                arg1 = get_locint_r();
     2112
     2113                ASSIGN_T(Targ1, rpp_T[arg1])
     2114                arg = (size_t)trunc(fabs(TARG1));
     2115
     2116                ASSIGN_A(Ares, rpp_A[res])
     2117                ASSIGN_A(Aarg, rpp_A[arg])
     2118
     2119                FOR_0_LE_l_LT_p
     2120                if (0 == ARES) {
     2121                    HOV_INC(Aarg, k1)
     2122                    HOV_INC(Ares, k1)
     2123                } else {
     2124                    MAXDEC(AARG,ARES);
     2125                    AARG_INC_O;
     2126                    ARES_INC = 0.0;
     2127                    FOR_0_LE_i_LT_k
     2128                    {
     2129                        AARG_INC += ARES;
     2130                        ARES_INC = 0.0;
     2131                    }
     2132                }
     2133                GET_TAYL(res,k,p)
     2134                break;
     2135
     2136            case ref_incr_a:                        /* Increment an adouble    incr_a */
     2137            case ref_decr_a:                        /* Increment an adouble    decr_a */
     2138                arg1   = get_locint_r();
     2139
     2140                ASSIGN_T(Targ1, rpp_T[arg1])
     2141                res = (size_t)trunc(fabs(TARG1));
     2142
     2143                GET_TAYL(res,k,p)
     2144                break;
     2145
     2146            case ref_assign_d:      /* assign an adouble variable a    assign_d */
     2147                /* double value. (=) */
     2148                coval = get_val_r();
     2149                // fallthrough
     2150            case ref_assign_d_zero: /* assign an adouble a        assign_d_zero */
     2151            case ref_assign_d_one:  /* double value. (=)           assign_d_one */
     2152                arg1   = get_locint_r();
     2153
     2154                ASSIGN_T(Targ1, rpp_T[arg1])
     2155                res = (size_t)trunc(fabs(TARG1));
     2156
     2157                ASSIGN_A(Ares, rpp_A[res])
     2158
     2159                FOR_0_LE_l_LT_pk1
     2160                ARES_INC = 0.0;
     2161
     2162                GET_TAYL(res,k,p)
     2163                break;
     2164
     2165            case ref_assign_a:     /* assign an adouble variable an    assign_a */
     2166                /* adouble value. (=) */
     2167                arg1 = get_locint_r();
     2168                arg = get_locint_r();
     2169
     2170                ASSIGN_T(Targ1, rpp_T[arg1])
     2171                res = (size_t)trunc(fabs(TARG1));
     2172
     2173                ASSIGN_A(Aarg, rpp_A[arg])
     2174                ASSIGN_A(Ares, rpp_A[res])
     2175
     2176                FOR_0_LE_l_LT_p
     2177                if  (0 == ARES) {
     2178                    HOV_INC(Aarg, k1)
     2179                    HOV_INC(Ares, k1)
     2180                } else {
     2181                    MAXDEC(AARG,ARES);
     2182                    AARG_INC_O;
     2183                    ARES_INC = 0.0;
     2184                    FOR_0_LE_i_LT_k
     2185                    { /* ! no tempory */
     2186                        AARG_INC += ARES;
     2187                        ARES_INC = 0.0;
     2188                    }
     2189                }
     2190
     2191                GET_TAYL(res,k,p)
     2192                break;
     2193
     2194            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
     2195                /* independent double value (<<=) */
     2196                arg1 = get_locint_r();
     2197                ASSIGN_T(Targ1, rpp_T[arg1])
     2198                res = (size_t)trunc(fabs(TARG1));
     2199                ASSIGN_A(Ares, rpp_A[res])
     2200
     2201                FOR_0_LE_l_LT_p
     2202                {
     2203#ifdef _HOV_
     2204                    if (nonzero) /* ??? question: why here? */
     2205                    nonzero[l][indexi] = (int)ARES;
     2206#endif /* _HOV_ */
     2207                    ARES_INC_O;
     2208                    FOR_0_LE_i_LT_k
     2209                        RESULTS(l,indexi,i) = ARES_INC;
     2210                }
     2211
     2212                GET_TAYL(res,k,p)
     2213                    indexi--;
     2214                break;
     2215
     2216        case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
     2217            /* adouble. (+=) */
     2218                arg1   = get_locint_r();
     2219                ASSIGN_T(Targ1, rpp_T[arg1])
     2220                res = (size_t)trunc(fabs(TARG1));
     2221                coval = get_val_r();
     2222
     2223                GET_TAYL(res,k,p)
     2224                break;
     2225
     2226            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
     2227                /* adouble. (+=) */
     2228                arg1 = get_locint_r();
     2229                arg = get_locint_r();
     2230
     2231                ASSIGN_T(Targ1, rpp_T[arg1])
     2232                res = (size_t)trunc(fabs(TARG1));
     2233                ASSIGN_A(Ares, rpp_A[res])
     2234                ASSIGN_A(Aarg, rpp_A[arg])
     2235
     2236                FOR_0_LE_l_LT_p
     2237                if  (0 == ARES) {
     2238                    HOV_INC(Ares, k1)
     2239                    HOV_INC(Aarg, k1)
     2240                } else {
     2241                    MAXDEC(AARG,ARES);
     2242                    AARG_INC_O;
     2243                    ARES_INC_O;
     2244                    FOR_0_LE_i_LT_k
     2245                    AARG_INC += ARES_INC;
     2246                }
     2247
     2248                GET_TAYL(res,k,p)
     2249                break;
     2250
     2251            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
     2252                /* adouble. (-=) */
     2253                arg1   = get_locint_r();
     2254                ASSIGN_T(Targ1, rpp_T[arg1])
     2255                res = (size_t)trunc(fabs(TARG1));
     2256                coval = get_val_r();
     2257
     2258                GET_TAYL(res,k,p)
     2259                break;
     2260
     2261            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
     2262                /* adouble. (-=) */
     2263                arg1 = get_locint_r();
     2264                arg = get_locint_r();
     2265               
     2266                ASSIGN_T(Targ1, rpp_T[arg1])
     2267                res = (size_t)trunc(fabs(TARG1));
     2268                ASSIGN_A(Ares, rpp_A[res])
     2269                ASSIGN_A(Aarg, rpp_A[arg])
     2270
     2271                FOR_0_LE_l_LT_p
     2272                if  (0==ARES) {
     2273                    HOV_INC(Ares, k1)
     2274                    HOV_INC(Aarg, k1)
     2275                } else {
     2276                    MAXDEC(AARG,ARES);
     2277                    AARG_INC_O;
     2278                    ARES_INC_O;
     2279                    FOR_0_LE_i_LT_k
     2280                    AARG_INC -= ARES_INC;
     2281                }
     2282
     2283                GET_TAYL(res,k,p)
     2284                break;
     2285
     2286            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
     2287                /* flaoting point. (*=) */
     2288                arg1   = get_locint_r();
     2289                ASSIGN_T(Targ1, rpp_T[arg1])
     2290                res = (size_t)trunc(fabs(TARG1));
     2291                coval = get_val_r();
     2292
     2293                ASSIGN_A(Ares, rpp_A[res])
     2294
     2295                FOR_0_LE_l_LT_p
     2296                if ( 0 == ARES_INC )
     2297                    HOV_INC(Ares, k)
     2298                    else
     2299                        FOR_0_LE_i_LT_k
     2300                        ARES_INC *= coval;
     2301
     2302                GET_TAYL(res,k,p)
     2303                break;
     2304
     2305        case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
     2306                /* (*=) */
     2307                arg1 = get_locint_r();
     2308                arg = get_locint_r();
     2309                ASSIGN_T(Targ1, rpp_T[arg1])
     2310                res = (size_t)trunc(fabs(TARG1));
     2311
     2312                GET_TAYL(res,k,p)
     2313
     2314                ASSIGN_A(Ares, rpp_A[res])
     2315                ASSIGN_A(Aarg, rpp_A[arg])
     2316                ASSIGN_A(Aqo,  rp_Atemp)
     2317                ASSIGN_T(Tres, rpp_T[res])
     2318                ASSIGN_T(Targ, rpp_T[arg])
     2319
     2320                FOR_0_LE_l_LT_p {
     2321                    if (0 == ARES) {
     2322                    HOV_INC(Aarg, k1)
     2323                        HOV_INC(Ares, k1)
     2324                    } else {
     2325                        MAXDEC(ARES,2.0);
     2326                        MAXDEC(AARG,ARES);
     2327                        AARG_INC_O;
     2328                        ARES_INC_O;
     2329                        conv(k,Ares,Targ,rp_Atemp);
     2330                        if(arg != res) {
     2331                            inconv(k,Ares,Tres,Aarg);
     2332                            FOR_0_LE_i_LT_k
     2333                            ARES_INC = AQO_INC;
     2334                        } else
     2335                            FOR_0_LE_i_LT_k
     2336                            ARES_INC = 2.0 * AQO_INC;
     2337                        HOV_INC(Aarg,k)
     2338                        HOS_OV_INC(Tres,k)
     2339                        HOS_OV_INC(Targ,k)
     2340                        HOS_OV_ASSIGN_A(Aqo,  rp_Atemp)
     2341                    }
     2342            }
     2343                break;
     2344
     2345            case ref_cond_assign:                                      /* cond_assign */
     2346            {   
     2347                revreal *Tref;
     2348                locint ref   = get_locint_r();
     2349                arg2  = get_locint_r();
     2350                arg1  = get_locint_r();
     2351                arg   = get_locint_r();
     2352                coval = get_val_r();
     2353               
     2354                ASSIGN_T(Tref, rpp_T[ref])
     2355
     2356#ifdef _HIGHER_ORDER_
     2357#define TREF  *Tref
     2358#else
     2359#define TREF   rpp_T[ref]
     2360#endif   
     2361
     2362                res = (size_t)trunc(fabs(TREF));
     2363#undef TREF
     2364                GET_TAYL(res,k,p)
     2365
     2366                ASSIGN_A(Aarg1, rpp_A[arg1])
     2367                ASSIGN_A(Ares,  rpp_A[res])
     2368                ASSIGN_A(Aarg2, rpp_A[arg2])
     2369                ASSIGN_T(Targ,  rpp_T[arg])
     2370
     2371                /* olvo 980925 changed code a little bit */
     2372                if (TARG > 0.0) {
     2373                    if (res != arg1)
     2374                        FOR_0_LE_l_LT_p
     2375                        { if (0 == ARES) {
     2376                          HOV_INC(Ares,  k1)
     2377                              HOV_INC(Aarg1, k1)
     2378                          } else {
     2379                              if (coval <= 0.0)
     2380                                  MINDEC(ret_c,2);
     2381                              MAXDEC(AARG1,ARES);
     2382                              ARES_INC = 0.0;
     2383                              AARG1_INC_O;
     2384                              FOR_0_LE_i_LT_k
     2385                              { AARG1_INC += ARES;
     2386                                ARES_INC = 0;
     2387                              }
     2388                          }
     2389                    }
     2390                    else
     2391                        FOR_0_LE_l_LT_p {
     2392                            if ((coval <= 0.0) && (ARES))
     2393                            MINDEC(ret_c,2);
     2394                            HOV_INC(Ares,  k1)
     2395                        }
     2396                    } else /* TARG <= 0.0 */
     2397            {
     2398                if (res != arg2)
     2399                        FOR_0_LE_l_LT_p
     2400                        { if (0 == ARES) {
     2401                          HOV_INC(Ares,  k1)
     2402                              HOV_INC(Aarg2, k1)
     2403                          } else {
     2404                              if (TARG == 0.0) /* we are at the tie */
     2405                              { MINDEC(ret_c,0);
     2406                                  AARG1 = 5.0;
     2407                                  AARG2_INC = 5.0;
     2408                              } else {
     2409                                  if (coval <= 0.0)
     2410                                      MINDEC(ret_c,2);
     2411                                  MAXDEC(AARG2,ARES);
     2412                                  AARG2_INC_O;
     2413                              }
     2414                              ARES_INC = 0.0;
     2415
     2416                              FOR_0_LE_i_LT_k
     2417                              { AARG2_INC += ARES;
     2418                                ARES_INC = 0;
     2419                              }
     2420                          }
     2421                      HOV_INC(Aarg1, k1)
     2422                    } else
     2423                        FOR_0_LE_l_LT_p {
     2424                            if (ARES) {
     2425                            if (TARG == 0.0) /* we are at the tie */
     2426                                { MINDEC(ret_c,0);
     2427                                    AARG1 = 5.0;
     2428                                    AARG2 = 5.0;
     2429                                } else
     2430                                    if (coval <= 0.0)
     2431                                        MINDEC(ret_c,2);
     2432                            }
     2433                        HOV_INC(Ares,  k1)
     2434                        HOV_INC(Aarg1, k1)
     2435                        HOV_INC(Aarg2, k1)
     2436                    }
     2437                }
     2438            }
     2439                break;
     2440
     2441            case ref_cond_assign_s:                                  /* cond_assign_s */
     2442                arg2   = get_locint_r();
     2443                arg1  = get_locint_r();
     2444                arg   = get_locint_r();
     2445                coval = get_val_r();
     2446               
     2447                ASSIGN_T(Targ2, rpp_T[arg2])
     2448                res = (size_t)trunc(fabs(TARG2));
     2449
     2450                GET_TAYL(res,k,p)
     2451
     2452                ASSIGN_A(Aarg1, rpp_A[arg1])
     2453                ASSIGN_A(Ares,  rpp_A[res])
     2454                ASSIGN_T(Targ,  rpp_T[arg])
     2455
     2456                /* olvo 980925 changed code a little bit */
     2457                if (TARG == 0.0) /* we are at the tie */
     2458                { FOR_0_LE_l_LT_p
     2459                    { if  (ARES)
     2460                      AARG1 = 5.0;
     2461                      HOV_INC(Aarg1, k1)
     2462                      HOV_INC(Ares,  k1)
     2463                    }
     2464                    MINDEC(ret_c,0);
     2465                } else
     2466                    if (TARG > 0.0) {
     2467                        if (res != arg1)
     2468                            FOR_0_LE_l_LT_p
     2469                            { if  (0 == ARES) {
     2470                              HOV_INC(Ares,  k1)
     2471                                  HOV_INC(Aarg1, k1)
     2472                              } else {
     2473                                  if (coval <= 0.0)
     2474                                      MINDEC(ret_c,2);
     2475                                  MAXDEC(AARG1,ARES);
     2476                                  ARES_INC = 0.0;
     2477                                  AARG1_INC_O;
     2478                                  FOR_0_LE_i_LT_k
     2479                                  { (AARG1_INC) += ARES;
     2480                                    ARES_INC = 0;
     2481                                  }
     2482                              }
     2483                        }
     2484                        else
     2485                            FOR_0_LE_l_LT_p {
     2486                                if ((coval <= 0.0) && (ARES))
     2487                                MINDEC(ret_c,2);
     2488                                HOV_INC(Ares,  k1)
     2489                            }
     2490                        }
     2491            break;
     2492
    20422493                /****************************************************************************/
    20432494                /*                                                          REMAINING STUFF */
  • branches/advector/ADOL-C/src/oplate.h

    r106 r284  
    66 
    77 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    8                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
     8               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     9               Kshitij Kulshreshtha
    910 
    1011 This file is part of ADOL-C. This software is provided as open source.
     
    1617#if !defined(ADOLC_OPLATE_P_H)
    1718#define ADOLC_OPLATE_P_H 1
    18 
    19 #include <adolc/common.h>
    2019
    2120/****************************************************************************/
     
    8382  floor_op,
    8483  ext_diff,
    85   ignore_me
     84  ignore_me,
     85  subscript = 80,
     86  subscript_ref,
     87  ref_assign_d_zero,
     88  ref_assign_d_one,
     89  ref_assign_d,
     90  ref_assign_a,
     91  ref_assign_ind,
     92  ref_incr_a,
     93  ref_decr_a,
     94  ref_eq_plus_d,
     95  ref_eq_min_d,
     96  ref_eq_plus_a,
     97  ref_eq_min_a,
     98  ref_eq_mult_d,
     99  ref_eq_mult_a,
     100  ref_copyout,
     101  ref_cond_assign,
     102  ref_cond_assign_s
    86103};
    87104
  • branches/advector/ADOL-C/src/sparse/sparsedrivers.cpp

    r267 r284  
    1313----------------------------------------------------------------------------*/
    1414#include <adolc/sparse/sparsedrivers.h>
    15 #include <adolc/oplate.h>
     15#include "oplate.h"
    1616#include <adolc/adalloc.h>
    1717#include <adolc/interfaces.h>
  • branches/advector/ADOL-C/src/tape_handling.cpp

    r269 r284  
    171171    storePtr = new double[groesse];
    172172    indexFeld = new locint[groesse];
    173     memset(storePtr, 0, groesse*sizeof(double));
    174173    // we use index 0 as end-of-list marker
    175174    size_t i = 1;
  • branches/advector/ADOL-C/src/tapedoc/tapedoc.c

    r249 r284  
    1616
    1717#include <adolc/tapedoc/tapedoc.h>
    18 #include <adolc/oplate.h>
     18#include "oplate.h"
    1919#include "taping_p.h"
    2020#include <adolc/adalloc.h>
  • branches/advector/ADOL-C/src/taping.c

    r275 r284  
    1818#include <string.h>
    1919
    20 #include <adolc/oplate.h>
     20#include "oplate.h"
    2121#include "taping_p.h"
    2222
  • branches/advector/ADOL-C/src/uni5_for.c

    r272 r284  
    2121 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    2222               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
    23                Benjamin Letschert
     23               Benjamin Letschert, Kshitij Kulshreshtha
     24               
    2425
    2526 This file is part of ADOL-C. This software is provided as open source.
     
    3334#include <adolc/taping.h>
    3435#include "taping_p.h"
    35 #include <adolc/oplate.h>
     36#include "oplate.h"
    3637#include <adolc/externfcts.h>
    3738#include "externfcts_p.h"
     
    35183519                break;
    35193520
     3521
     3522                /*--------------------------------------------------------------------------*/
     3523            case subscript:
     3524                coval = get_val_f();
     3525                if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= coval + 2) {
     3526                    fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],coval);
     3527                    exit(-2);
     3528                }
     3529                arg = get_locint_f();
     3530                res = get_locint_f();
     3531                {
     3532                    size_t cnt, idx, numvar = (size_t)trunc(fabs(coval));
     3533                    locint vectorloc[numvar];
     3534                    for (cnt = 0; cnt < numvar; cnt++)
     3535                        vectorloc[cnt] = get_locint_f();
     3536#if !defined(_NTIGHT_)
     3537                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     3538                    arg1 = vectorloc[idx];
     3539                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     3540                    dp_T0[res] = dp_T0[arg1];
     3541#if defined(_INDO_)
     3542                    copy_index_domain(res, arg1, ind_dom);
     3543#else
     3544#if !defined(_ZOS_) /* BREAK_ZOS */
     3545                    ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
     3546                    ASSIGN_T(Tres,TAYLOR_BUFFER[res])
     3547
     3548                    FOR_0_LE_l_LT_pk
     3549                    TRES_INC = TARG1_INC;
     3550#endif
     3551#endif
     3552#else
     3553                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
     3554                    exit(-2);
     3555#endif /* ALL_TOGETHER_AGAIN */
     3556                }
     3557                break;
     3558
     3559            case subscript_ref:
     3560                coval = get_val_f();
     3561                if (ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE] <= coval + 2) {
     3562                    fprintf( DIAG_OUT, "ADOL-C error: LBUFSIZE=%d is too small for operating on advector of size=%d, need > size+2",ADOLC_CURRENT_TAPE_INFOS.stats[LOC_BUFFER_SIZE],coval);
     3563                    exit(-2);
     3564                }
     3565                arg = get_locint_f();
     3566                res = get_locint_f();
     3567                {
     3568                    size_t cnt, idx, numvar = (size_t)trunc(fabs(coval));
     3569                    locint vectorloc[numvar];
     3570                    for (cnt = 0; cnt < numvar; cnt++)
     3571                        vectorloc[cnt] = get_locint_f();
     3572#if !defined(_NTIGHT_)
     3573                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     3574                    arg1 = vectorloc[idx];
     3575                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     3576                    dp_T0[res] = arg1;
     3577#else
     3578                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
     3579                    exit(-2);
     3580#endif
     3581                }
     3582                break;
     3583
     3584            case ref_copyout:
     3585                arg = get_locint_f();
     3586                res = get_locint_f();
     3587#if !defined(_NTIGHT_)
     3588                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3589                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     3590                dp_T0[res] = dp_T0[arg1];
     3591#if defined(_INDO_)
     3592                copy_index_domain(res, arg1, ind_dom);
     3593#else
     3594#if !defined(_ZOS_) /* BREAK_ZOS */
     3595                ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
     3596                ASSIGN_T(Tres,TAYLOR_BUFFER[res])
     3597
     3598                FOR_0_LE_l_LT_pk
     3599                TRES_INC = TARG1_INC;
     3600#endif
     3601#endif
     3602#else
     3603                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3604                exit(-2);
     3605#endif /* ALL_TOGETHER_AGAIN */
     3606                break;
     3607
     3608            case ref_incr_a:
     3609                arg = get_locint_f();
     3610#if !defined(_NTIGHT_)
     3611                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3612                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p);
     3613                dp_T0[arg1]++;
     3614#else
     3615                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3616                exit(-2);
     3617#endif
     3618                break;
     3619
     3620            case ref_decr_a:
     3621                arg = get_locint_f();
     3622#if !defined(_NTIGHT_)
     3623                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3624                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p);
     3625                dp_T0[arg1]--;
     3626#else
     3627                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3628                exit(-2);
     3629#endif
     3630                break;
     3631
     3632            case ref_assign_d:
     3633                arg = get_locint_f();
     3634                coval = get_val_f();
     3635               
     3636#if !defined(_NTIGHT_)
     3637                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3638                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
     3639                dp_T0[arg1] = coval;
     3640#if defined(_INDO_)
     3641                ind_dom[arg1][0] = 0;
     3642#else
     3643#if !defined(_ZOS_)
     3644                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     3645
     3646                FOR_0_LE_l_LT_pk
     3647                TARG1_INC = 0;
     3648#endif
     3649#endif
     3650#else
     3651                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3652                exit(-2);
     3653#endif
     3654                break;
     3655
     3656            case ref_assign_d_zero:
     3657                arg = get_locint_f();
     3658
     3659#if !defined(_NTIGHT_)
     3660                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3661                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
     3662                dp_T0[arg1] = 0.0;
     3663#if defined(_INDO_)
     3664                ind_dom[arg1][0] = 0;
     3665#else
     3666#if !defined(_ZOS_)
     3667                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     3668
     3669                FOR_0_LE_l_LT_pk
     3670                TARG1_INC = 0;
     3671#endif
     3672#endif
     3673#else
     3674                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3675                exit(-2);
     3676#endif
     3677                break;
     3678
     3679            case ref_assign_d_one:
     3680                arg = get_locint_f();
     3681
     3682#if !defined(_NTIGHT_)
     3683                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     3684                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
     3685                dp_T0[arg1] = 1.0;
     3686#if defined(_INDO_)
     3687                ind_dom[arg1][0] = 0;
     3688#else
     3689#if !defined(_ZOS_)
     3690                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     3691
     3692                FOR_0_LE_l_LT_pk
     3693                TARG1_INC = 0;
     3694#endif
     3695#endif
     3696#else
     3697                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3698                exit(-2);
     3699#endif
     3700                break;
     3701
     3702            case ref_assign_a:           /* assign an adouble variable an    assign_a */
     3703                /* adouble value. (=) */
     3704                arg = get_locint_f();
     3705                res = get_locint_f();
     3706
     3707#if !defined(_NTIGHT_)
     3708                arg1 = (size_t)trunc(fabs(dp_T0[res]));
     3709                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
     3710                dp_T0[arg1] = dp_T0[arg];
     3711#if defined(_INDO_)
     3712                copy_index_domain(arg1, arg, ind_dom);
     3713#else
     3714#if !defined(_ZOS_) /* BREAK_ZOS */
     3715                ASSIGN_T(Targ,TAYLOR_BUFFER[arg])
     3716                ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
     3717
     3718                FOR_0_LE_l_LT_pk
     3719                TARG1_INC = TARG_INC;
     3720#endif
     3721#endif
     3722#else
     3723                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3724                exit(-2);
     3725#endif /* ALL_TOGETHER_AGAIN */
     3726                break;
     3727
     3728            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
     3729                /* independent double value (<<=) */
     3730                arg = get_locint_f();
     3731
     3732
     3733#if !defined(_NTIGHT_)
     3734                res = (size_t)trunc(fabs(dp_T0[arg]));
     3735                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3736                dp_T0[res] = basepoint[indexi];
     3737#if defined(_INDO_)
     3738                ind_dom[res][0] = 1;
     3739                ind_dom[res][2] = indexi;
     3740#else
     3741#if !defined(_ZOS_) /* BREAK_ZOS */
     3742                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3743
     3744#ifdef _INT_FOR_
     3745                FOR_0_LE_l_LT_p
     3746                TRES_INC = ARGUMENT(indexi,l,i);
     3747#else
     3748                FOR_0_LE_l_LT_p
     3749                FOR_0_LE_i_LT_k
     3750                TRES_INC = ARGUMENT(indexi,l,i);
     3751#endif
     3752#endif
     3753#endif
     3754#else
     3755                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3756                exit(-2);
     3757#endif /* ALL_TOGETHER_AGAIN */
     3758                ++indexi;
     3759                break;
     3760
     3761            case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
     3762                /* adouble. (+=) */
     3763                arg  = get_locint_f();
     3764                coval = get_val_f();
     3765
     3766
     3767#if !defined(_NTIGHT_)
     3768                res = (size_t)trunc(fabs(dp_T0[arg]));
     3769                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3770                dp_T0[res] += coval;
     3771#else
     3772                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3773                exit(-2);
     3774#endif /* !_NTIGHT_ */
     3775                break;
     3776
     3777                /*--------------------------------------------------------------------------*/
     3778            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
     3779                /* adouble. (+=) */
     3780                arg = get_locint_f();
     3781                arg1 = get_locint_f();
     3782
     3783#if !defined(_NTIGHT_)
     3784                res = (size_t)trunc(fabs(dp_T0[arg1]));
     3785                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3786                dp_T0[res] += dp_T0[arg];
     3787#if defined(_INDO_)
     3788                merge_2_index_domains(res, arg, ind_dom);
     3789#else
     3790#if !defined(_ZOS_) /* BREAK_ZOS */
     3791                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3792                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     3793
     3794#ifdef _INT_FOR_
     3795                FOR_0_LE_l_LT_pk
     3796                TRES_INC |= TARG_INC;
     3797#else
     3798                FOR_0_LE_l_LT_pk
     3799                TRES_INC += TARG_INC;
     3800#endif
     3801#endif
     3802#endif
     3803#else
     3804                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3805                exit(-2);
     3806#endif /* ALL_TOGETHER_AGAIN */
     3807                break;
     3808
     3809            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
     3810                /* adouble. (-=) */
     3811                arg = get_locint_f();
     3812                coval = get_val_f();
     3813
     3814#if !defined(_NTIGHT_)
     3815                res = (size_t)trunc(fabs(dp_T0[arg]));
     3816                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3817                dp_T0[res] -= coval;
     3818#else
     3819                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3820                exit(-2);
     3821#endif /* !_NTIGHT_ */
     3822                break;
     3823
     3824                /*--------------------------------------------------------------------------*/
     3825            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
     3826                /* adouble. (-=) */
     3827                arg = get_locint_f();
     3828                arg1 = get_locint_f();
     3829
     3830#if !defined(_NTIGHT_)
     3831                res = (size_t)trunc(fabs(dp_T0[arg1]));
     3832                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3833                dp_T0[res] -= dp_T0[arg];
     3834#if defined(_INDO_)
     3835                merge_2_index_domains(res, arg, ind_dom);
     3836#else
     3837#if !defined(_ZOS_) /* BREAK_ZOS */
     3838                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3839                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     3840
     3841#ifdef _INT_FOR_
     3842                FOR_0_LE_l_LT_pk
     3843                TRES_INC |= TARG_INC;
     3844#else
     3845                FOR_0_LE_l_LT_pk
     3846                TRES_INC -= TARG_INC;
     3847#endif
     3848#endif
     3849#endif
     3850#else
     3851                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3852                exit(-2);
     3853#endif /* ALL_TOGETHER_AGAIN */
     3854                break;
     3855
     3856            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
     3857                /* flaoting point. (*=) */
     3858                arg = get_locint_f();
     3859                coval = get_val_f();
     3860
     3861#if !defined(_NTIGHT_)
     3862                res = (size_t)trunc(fabs(dp_T0[arg]));
     3863                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3864                dp_T0[res] *= coval;
     3865#if !defined(_INDO_)
     3866#if !defined(_ZOS_) /* BREAK_ZOS */
     3867#if !defined( _INT_FOR_)
     3868
     3869                FOR_0_LE_l_LT_pk
     3870                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3871
     3872                FOR_0_LE_l_LT_pk
     3873                TRES_INC *= coval;
     3874#endif
     3875#endif
     3876#endif
     3877#else
     3878                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3879                exit(-2);
     3880#endif /* ALL_TOGETHER_AGAIN */
     3881                break;
     3882
     3883            case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
     3884                /* (*=) */
     3885                arg = get_locint_f();
     3886                arg1 = get_locint_f();
     3887
     3888#if !defined(_NTIGHT_)
     3889                res = (size_t)trunc(fabs(dp_T0[arg1]));
     3890                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3891#if defined(_INDO_)
     3892                merge_2_index_domains(res, arg, ind_dom);
     3893#if defined(_NONLIND_)
     3894                extend_nonlinearity_domain_binary(res, arg, ind_dom, nonl_dom);
     3895#endif
     3896#else
     3897#if !defined(_ZOS_) /* BREAK_ZOS */
     3898                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3899                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     3900
     3901                INC_pk_1(Tres)
     3902                INC_pk_1(Targ)
     3903
     3904#ifdef _INT_FOR_
     3905                FOR_p_GT_l_GE_0
     3906                TRES_FODEC |= TARG_DEC;
     3907#else
     3908                FOR_p_GT_l_GE_0
     3909                FOR_k_GT_i_GE_0
     3910                { TRES_FODEC = dp_T0[res]*TARG_DEC +
     3911                               TRES*dp_T0[arg];
     3912                  DEC_TRES_FO
     3913#ifdef _HIGHER_ORDER_
     3914                  TresOP = Tres-i;
     3915                  TargOP = Targ;
     3916
     3917                  for (j=0;j<i;j++)
     3918                  *Tres += (*TresOP++) * (*TargOP--);
     3919                  Tres--;
     3920#endif /* _HIGHER_ORDER_ */
     3921                }
     3922#endif
     3923#endif
     3924#endif
     3925                dp_T0[res] *= dp_T0[arg];
     3926#else
     3927                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     3928                exit(-2);
     3929#endif /* !_NTIGHT_ */
     3930                break;
     3931
     3932            case ref_cond_assign:                                      /* cond_assign */
     3933                arg   = get_locint_f();
     3934                arg1  = get_locint_f();
     3935                arg2  = get_locint_f();
     3936                {
     3937                    locint ref = get_locint_f();
     3938                    coval = get_val_f();
     3939#if !defined(_NTIGHT_)
     3940                    res   = (size_t)trunc(fabs(dp_T0[ref]));
     3941
     3942                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3943
     3944                /* olvo 980924 changed order to allow reflexive ops */
     3945#if defined(_INDO_)
     3946                if (dp_T0[arg] > 0) {
     3947                    if (coval <= 0.0)
     3948                        MINDEC(ret_c,2);
     3949                    dp_T0[res] = dp_T0[arg1];
     3950
     3951                    combine_2_index_domains(res, arg1, arg2, ind_dom);
     3952                } else {
     3953                    if (coval > 0.0)
     3954                        MINDEC(ret_c,2);
     3955                    if (dp_T0[arg] == 0)
     3956                        MINDEC(ret_c,0);
     3957                    dp_T0[res] = dp_T0[arg2];
     3958
     3959                    combine_2_index_domains(res, arg1, arg2, ind_dom);
     3960                }
     3961#else
     3962#if !defined(_ZOS_) /* BREAK_ZOS */
     3963                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     3964                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     3965                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
     3966#endif /* ALL_TOGETHER_AGAIN */
     3967
     3968#ifdef _INT_FOR_
     3969                coval = get_val_f();
     3970
     3971                if (dp_T0[arg] > 0)
     3972                    FOR_0_LE_l_LT_pk
     3973                    TRES_INC = TARG1_INC;
     3974                else
     3975                    FOR_0_LE_l_LT_pk
     3976                    TRES_INC = TARG2_INC;
     3977
     3978                if (dp_T0[arg] > 0) {
     3979                    if (coval <= 0.0)
     3980                        MINDEC(ret_c,2);
     3981                    dp_T0[res] = dp_T0[arg1];
     3982                } else {
     3983                    if (coval > 0.0)
     3984                        MINDEC(ret_c,2);
     3985                    if (dp_T0[arg] == 0)
     3986                        MINDEC(ret_c,0);
     3987                    dp_T0[res] = dp_T0[arg2];
     3988                }
     3989                FOR_0_LE_l_LT_pk
     3990                TRES_INC = TARG1_INC | TARG2_INC;
     3991#else
     3992#if !defined(_ZOS_) /* BREAK_ZOS */
     3993                if (dp_T0[arg] > 0)
     3994                    FOR_0_LE_l_LT_pk
     3995                    TRES_INC = TARG1_INC;
     3996                else
     3997                    FOR_0_LE_l_LT_pk
     3998                    TRES_INC = TARG2_INC;
     3999#endif
     4000
     4001                if (dp_T0[arg] > 0) {
     4002                    if (coval <= 0.0)
     4003                        MINDEC(ret_c,2);
     4004                    dp_T0[res] = dp_T0[arg1];
     4005                } else {
     4006                    if (coval > 0.0)
     4007                        MINDEC(ret_c,2);
     4008                    if (dp_T0[arg] == 0)
     4009                        MINDEC(ret_c,0);
     4010                    dp_T0[res] = dp_T0[arg2];
     4011                }
     4012#endif
     4013#endif
     4014#else
     4015                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     4016                exit(-2);
     4017#endif /* ALL_TOGETHER_AGAIN */
     4018                }
     4019                break;
     4020
     4021            case ref_cond_assign_s:                                  /* cond_assign_s */
     4022                arg   = get_locint_f();
     4023                arg1  = get_locint_f();
     4024                arg2   = get_locint_f();
     4025                coval = get_val_f();
     4026
     4027#if !defined(_NTIGHT_)
     4028                res = (size_t)trunc(fabs(dp_T0[arg2]));
     4029                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     4030
     4031                /* olvo 980924 changed order to allow reflexive ops */
     4032#if defined(_INDO_)
     4033                    copy_index_domain(res, arg1, ind_dom);
     4034#else
     4035#if !defined(_ZOS_) /* BREAK_ZOS */
     4036                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     4037                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     4038#endif /* ALL_TOGETHER_AGAIN */
     4039
     4040#ifdef _INT_FOR_
     4041                coval = get_val_f();
     4042
     4043                if (dp_T0[arg] > 0)
     4044                    FOR_0_LE_l_LT_pk
     4045                    TRES_INC = TARG1_INC;
     4046
     4047                if (dp_T0[arg] > 0) {
     4048                    if (coval <= 0.0)
     4049                        MINDEC(ret_c,2);
     4050                    dp_T0[res] = dp_T0[arg1];
     4051                } else
     4052                    if (dp_T0[arg] == 0)
     4053                        MINDEC(ret_c,0);
     4054#else
     4055#if !defined(_ZOS_) /* BREAK_ZOS */
     4056                if (dp_T0[arg] > 0)
     4057                    FOR_0_LE_l_LT_pk
     4058                    TRES_INC = TARG1_INC;
     4059#endif
     4060                if (dp_T0[arg] > 0) {
     4061                    if (coval <= 0.0)
     4062                        MINDEC(ret_c,2);
     4063                    dp_T0[res] = dp_T0[arg1];
     4064                } else
     4065                    if (dp_T0[arg] == 0)
     4066                        MINDEC(ret_c,0);
     4067#endif
     4068#endif
     4069#else
     4070                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     4071                exit(-2);
     4072#endif /* ALL_TOGETHER_AGAIN */
     4073                break;
    35204074
    35214075                /****************************************************************************/
  • branches/advector/MSVisualStudio/v10/installer.sh

    r213 r284  
    22INCFILES=(adolc.h adalloc.h adouble.h adutils.h adutilsc.h \
    33         common.h convolut.h dvlparms.h fortutils.h \
    4          interfaces.h oplate.h taping.h usrparms.h \
     4         interfaces.h taping.h usrparms.h \
    55         externfcts.h checkpointing.h fixpoint.h \
    66         adolc_sparse.h adolc_openmp.h \
    7          revolve.h)
     7         revolve.h advector.h)
    88INCFILES_SPARSE=(sparsedrivers.h sparse_fo_rev.h)
    99
Note: See TracChangeset for help on using the changeset viewer.