ADMB Documentation  11.1.1631
 All Classes Files Functions Variables Typedefs Friends Defines
adpvm2.cpp
Go to the documentation of this file.
00001 /*
00002  * $Id: adpvm2.cpp 1112 2013-07-12 21:41:41Z johnoel $
00003  *
00004  * Author: David Fournier
00005  * Copyright (c) 2008-2012 Regents of the University of California
00006  */
00011 //#if defined(__BORLANDC__) && !defined(__linux__)
00012 
00013 #include <stdio.h>
00014 #if defined(__MSVC32__)
00015 #  define WIN32
00016 #endif
00017 
00018 #if defined(__BORLANDC__)
00019 #define WIN32
00020 #endif
00021 #include "adpvm2.h"
00022 //#if defined(__BORLANDC__)
00023 #define AD_USE_DYNAMIC_LOAD
00024 //#endif
00025 
00026 #if defined AD_USE_DYNAMIC_LOAD
00027 
00028 #define HAVE_PVM
00029 
00030 int ad_constant_flag=0;
00031 
00032 //#define  __declspec(dllexport)
00033 
00034 #define AD__PRELOAD
00035 
00040 int load_adpvm_library(void)
00041 {
00042   int ierr=0;
00043   return ierr;
00044 }
00045 
00046 
00047 #if defined(USE_ADPVM)
00048 
00053 void adpvm_pack_number_derivative(void)
00054 {
00055   verify_identifier_string("D");
00056   prevariable_position dvpos=restore_prevariable_position();
00057   double dv=restore_prevariable_derivative(dvpos);
00058   pvm_pack(dv);
00059   verify_identifier_string("C");
00060 }
00061 
00066 void adpvm_pack_index_bounds(void)
00067 {
00068   verify_identifier_string("L");
00069   int imax=restore_int_value();
00070   int imin=restore_int_value();
00071   verify_identifier_string("K");
00072   //pvm_pkint(&imin,1,1);
00073   //pvm_pkint(&imax,1,1);
00074 }
00075 
00080 void adpvm_unpack(const prevariable& _v)
00081 {
00082   dvariable& v = (dvariable&) _v;
00083   save_identifier_string("C");
00084   v.save_prevariable_position();
00085   save_identifier_string("D");
00086   pvm_upkdouble((double*)(&(value(v))),1,1);
00087   gradient_structure::GRAD_STACK1->
00088             set_gradient_stack(adpvm_pack_number_derivative);
00089 }
00090 
00095 void adpvm_unpack(const double& _v)
00096 {
00097   double& v = (double&) _v;
00098   pvm_upkdouble(&v,1,1);
00099 }
00100 
00105 void adpvm_unpack(const int& _v)
00106 {
00107   int& v = (int&) _v;
00108   pvm_upkint(&v,1,1);
00109 }
00110 
00115 void adpvm_send_derivatives(void)
00116 {
00117   verify_identifier_string("F");
00118   int n=restore_int_value();
00119   int id=restore_int_value();
00120   verify_identifier_string("E");
00121   int icheck =pvm_send(id,2);
00122 }
00123 
00124 #if defined(HAVE_PVM)
00125 
00130 int adpvm_recv(int id,int n)
00131 {
00132   int status=pvm_recv(id,n);
00133   //cout << status << endl;
00134   if (!ad_constant_flag)
00135   {
00136     save_identifier_string("E");
00137     save_int_value(id);
00138     save_int_value(n);
00139     save_identifier_string("F");
00140     gradient_structure::GRAD_STACK1->
00141             set_gradient_stack(adpvm_send_derivatives);
00142   }
00143   return status;
00144 }
00145 #else
00146 
00151 int adpvm_recv(int id,int n)
00152 {
00153   return 0;
00154 }
00155 #endif
00156 
00161 void adpvm_receive_derivatives(void)
00162 {
00163   verify_identifier_string("H");
00164   int n=restore_int_value();
00165   int id=restore_int_value();
00166   verify_identifier_string("G");
00167   int bid=0;
00168   if ( (bid=pvm_recv(id,2))<0)
00169   {
00170     cerr << "error in adpvm_receive_derivatvies" << endl;
00171     ad_exit(1);
00172   }
00173 }
00174 
00175 #if defined(HAVE_PVM)
00176 
00181 void adpvm_send(int id,int n)
00182 {
00183   int err=pvm_send(id,n);
00184   //cout << err << endl;
00185   if (!ad_constant_flag)
00186   {
00187     save_identifier_string("G");
00188     save_int_value(id);
00189     save_int_value(n);
00190     save_identifier_string("H");
00191     gradient_structure::GRAD_STACK1->
00192       set_gradient_stack(adpvm_receive_derivatives);
00193   }
00194 }
00195 #else
00196 
00201 void adpvm_send(int id,int n)
00202 {
00203 }
00204 #endif
00205 
00210 void adpvm_unpack_vector_derivatives(void)
00211 {
00212   kkludge_object kk;
00213   verify_identifier_string("Y");
00214   dvar_vector_position dvpos=restore_dvar_vector_position();
00215   verify_identifier_string("X");
00216   dvector v(dvpos,kk);
00217   pvm_unpack(v);
00218   v.save_dvector_derivatives(dvpos);
00219 }
00220 
00225 void adpvm_pack(const dvar_vector& _v)
00226 {
00227   dvar_vector& v =(dvar_vector&) _v;
00228   int imin=v.indexmin();
00229   int imax=v.indexmax();
00230   pvm_pkint(&imin,1,1);
00231   pvm_pkint(&imax,1,1);
00232   pvm_pkdouble(&(value(v(imin))),imax-imin+1,1);
00233 
00234   save_identifier_string("X");
00235   v.save_dvar_vector_position();
00236   save_identifier_string("Y");
00237   gradient_structure::GRAD_STACK1->
00238             set_gradient_stack(adpvm_unpack_vector_derivatives);
00239 }
00240 
00245 void adpvm_pack(const dvar_matrix & _m)
00246 {
00247   dvar_matrix& m = (dvar_matrix &) _m;
00248   if (allocated(m))
00249   {
00250     int imin=m.indexmin();
00251     int imax=m.indexmax();
00252     pvm_pkint(&imin,1,1);
00253     pvm_pkint(&imax,1,1);
00254     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00255   }
00256   else
00257   {
00258     int imin=0;
00259     int imax=-1;
00260     pvm_pkint(&imin,1,1);
00261     pvm_pkint(&imax,1,1);
00262   }
00263 }
00264 
00269 void adpvm_pack(const dvar3_array & _m)
00270 {
00271   dvar3_array& m = (dvar3_array &) _m;
00272   if (allocated(m))
00273   {
00274     int imin=m.indexmin();
00275     int imax=m.indexmax();
00276     pvm_pkint(&imin,1,1);
00277     pvm_pkint(&imax,1,1);
00278     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00279   }
00280   else
00281   {
00282     int imin=0;
00283     int imax=-1;
00284     pvm_pkint(&imin,1,1);
00285     pvm_pkint(&imax,1,1);
00286   }
00287 }
00288 
00293 void adpvm_pack(const dvar4_array & _m)
00294 {
00295   dvar4_array& m = (dvar4_array &) _m;
00296   if (allocated(m))
00297   {
00298     int imin=m.indexmin();
00299     int imax=m.indexmax();
00300     pvm_pkint(&imin,1,1);
00301     pvm_pkint(&imax,1,1);
00302     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00303   }
00304   else
00305   {
00306     int imin=0;
00307     int imax=-1;
00308     pvm_pkint(&imin,1,1);
00309     pvm_pkint(&imax,1,1);
00310   }
00311 }
00312 
00317 void adpvm_pack(const dvar5_array & _m)
00318 {
00319   dvar5_array& m = (dvar5_array &) _m;
00320   if (allocated(m))
00321   {
00322     int imin=m.indexmin();
00323     int imax=m.indexmax();
00324     pvm_pkint(&imin,1,1);
00325     pvm_pkint(&imax,1,1);
00326     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00327   }
00328   else
00329   {
00330     int imin=0;
00331     int imax=-1;
00332     pvm_pkint(&imin,1,1);
00333     pvm_pkint(&imax,1,1);
00334   }
00335 }
00336 
00341 void initialize_pvm_buffer(void)
00342 {
00343   int bufid = pvm_initsend( PvmDataDefault );
00344 }
00345 
00350 int adpvm_initsend( int mode )
00351 {
00352   int bufid = pvm_initsend( mode );
00353   return bufid;
00354 }
00355 
00360 void  adpvm_end_receive(void)
00361 {
00362   gradient_structure::GRAD_STACK1->
00363             set_gradient_stack(initialize_pvm_buffer);
00364 }
00365 
00370 void adpvm_unpack_number_derivative(void)
00371 {
00372   verify_identifier_string("S");
00373   double dv;
00374   pvm_upkdouble(&dv,1,1);;
00375   prevariable_position dvpos=restore_prevariable_position();
00376   verify_identifier_string("R");
00377   save_double_derivative(dv,dvpos);
00378 }
00379 
00384 void adpvm_pack(const prevariable& _v)
00385 {
00386   prevariable& v = (prevariable&) _v;
00387   save_identifier_string("R");
00388   v.save_prevariable_position();
00389   save_identifier_string("S");
00390   pvm_pkdouble((double*)(&(value(v))),1,1);
00391   gradient_structure::GRAD_STACK1->
00392             set_gradient_stack(adpvm_unpack_number_derivative);
00393 }
00394 
00399 void adpvm_pack_vector_derivatives(void)
00400 {
00401   //int bufid = adpvm_initsend( PvmDataRaw );
00402   verify_identifier_string("D");
00403   dvar_vector_position dvpos=restore_dvar_vector_position();
00404   dvector dv=restore_dvar_vector_derivatives(dvpos);
00405   int imin=dv.indexmin();
00406   int imax=dv.indexmax();
00407   pvm_pack(dv);
00408   verify_identifier_string("B");
00409 }
00410 
00415 void adpvm_unpack(const dvar_vector& _v)
00416 {
00417   dvar_vector& v = (dvar_vector&) _v;
00418   int imin;
00419   int imax;
00420   pvm_upkint(&imin,1,1);
00421   pvm_upkint(&imax,1,1);
00422   if (allocated(v))
00423   {
00424     if (v.indexmin()!=imin)
00425     {
00426       cerr << "Error in min index in "
00427           "void adpvm_unpack(const dvar_vector& v)" << endl;
00428       ad_exit(1);
00429     }
00430     if (v.indexmax()!=imax)
00431     {
00432       cerr << "Error in max index in"
00433           " void adpvm_unpack(const dvar_vector& v)" << endl;
00434       ad_exit(1);
00435     }
00436   }
00437   else
00438   {
00439     v.allocate(imin,imax);
00440   }
00441   pvm_upkdouble(&(value(v(imin))),imax-imin+1,1);
00442   save_identifier_string("B");
00443   v.save_dvar_vector_position();
00444   save_identifier_string("D");
00445   gradient_structure::GRAD_STACK1->
00446             set_gradient_stack(adpvm_pack_vector_derivatives);
00447 }
00448 
00453 void adpvm_unpack(const dvar_matrix & _m)
00454 {
00455   dvar_matrix& m = (dvar_matrix &) _m;
00456   int imin;
00457   int imax;
00458   pvm_upkint(&imin,1,1);
00459   pvm_upkint(&imax,1,1);
00460   if (allocated(m)) {
00461     if (m.indexmin()!=imin) {
00462       cerr << "Error in min index in"
00463           " void adpvm_unpack(const dvar_matrix& v)" << endl;
00464       ad_exit(1);
00465     }
00466     if (m.indexmax()!=imax) {
00467       cerr << "Error in max index in"
00468           " void adpvm_unpack(const dvar_matrix& v)" << endl;
00469       ad_exit(1);
00470     }
00471   } else {
00472     m.allocate(imin,imax);
00473   }
00474   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00475   save_identifier_string("K");
00476   save_int_value(imin);
00477   save_int_value(imax);
00478   save_identifier_string("L");
00479   gradient_structure::GRAD_STACK1->
00480             set_gradient_stack(adpvm_pack_index_bounds);
00481 }
00482 
00487 void adpvm_unpack(const dvar3_array & _m)
00488 {
00489   dvar3_array& m = (dvar3_array &) _m;
00490   int imin;
00491   int imax;
00492   pvm_upkint(&imin,1,1);
00493   pvm_upkint(&imax,1,1);
00494   if (allocated(m)) {
00495     if (m.indexmin()!=imin) {
00496       cerr << "Error in min index in"
00497           " void adpvm_unpack(const dvar_3array& v)" << endl;
00498       ad_exit(1);
00499     }
00500     if (m.indexmax()!=imax) {
00501       cerr << "Error in max index in"
00502           " void adpvm_unpack(const dvar3_array& v)" << endl;
00503       ad_exit(1);
00504     }
00505   } else {
00506     m.allocate(imin,imax);
00507   }
00508   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00509 }
00510 
00515 void adpvm_unpack(const dvar4_array & _m)
00516 {
00517   dvar4_array& m = (dvar4_array &) _m;
00518   int imin;
00519   int imax;
00520   pvm_upkint(&imin,1,1);
00521   pvm_upkint(&imax,1,1);
00522   if (allocated(m)) {
00523     if (m.indexmin()!=imin) {
00524       cerr << "Error in min index in"
00525           " void adpvm_unpack(const dvector& v)" << endl;
00526       ad_exit(1);
00527     }
00528     if (m.indexmax()!=imax) {
00529       cerr << "Error in max index in"
00530           " void adpvm_unpack(const dvector& v)" << endl;
00531       ad_exit(1);
00532     }
00533   } else {
00534     m.allocate(imin,imax);
00535   }
00536   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00537 }
00538 
00543 void adpvm_unpack(const dvar5_array & _m)
00544 {
00545   dvar5_array& m = (dvar5_array &) _m;
00546   int imin;
00547   int imax;
00548   pvm_upkint(&imin,1,1);
00549   pvm_upkint(&imax,1,1);
00550   if (allocated(m)) {
00551     if (m.indexmin()!=imin) {
00552       cerr << "Error in min index in"
00553           " void adpvm_unpack(const dvector& v)" << endl;
00554       ad_exit(1);
00555     }
00556     if (m.indexmax()!=imax) {
00557       cerr << "Error in max index in"
00558           " void adpvm_unpack(const dvector& v)" << endl;
00559       ad_exit(1);
00560     }
00561   } else {
00562       m.allocate(imin,imax);
00563   }
00564   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00565 }
00566 
00571 void adpvm_pack(double v)
00572 {
00573   pvm_pkdouble(&v,1,1);
00574 }
00575 
00580 void adpvm_pack(char * v,int n)
00581 {
00582   pvm_pkbyte(v,n,1);
00583 }
00584 
00589 void adpvm_unpack(char * v,int n)
00590 {
00591   pvm_upkbyte(v,n,1);
00592 }
00593 
00598 void adpvm_pack(const dvector& _v)
00599 {
00600   dvector& v =(dvector&) _v;
00601   if (allocated(v))
00602   {
00603     int imin=v.indexmin();
00604     int imax=v.indexmax();
00605     pvm_pkint(&imin,1,1);
00606     pvm_pkint(&imax,1,1);
00607     pvm_pkdouble(&(v(imin)),imax-imin+1,1);
00608   }
00609   else
00610   {
00611     int imin=0;
00612     int imax=-1;
00613     pvm_pkint(&imin,1,1);
00614     pvm_pkint(&imax,1,1);
00615   }
00616 }
00617 
00622 void adpvm_pack(const dmatrix & _m)
00623 {
00624   dmatrix& m = (dmatrix &) _m;
00625   if (allocated(m))
00626   {
00627     int imin=m.indexmin();
00628     int imax=m.indexmax();
00629     pvm_pkint(&imin,1,1);
00630     pvm_pkint(&imax,1,1);
00631     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00632   }
00633   else
00634   {
00635     int imin=0;
00636     int imax=-1;
00637     pvm_pkint(&imin,1,1);
00638     pvm_pkint(&imax,1,1);
00639   }
00640 }
00641 
00646 void adpvm_pack(const d3_array & _m)
00647 {
00648   d3_array& m = (d3_array &) _m;
00649   if (allocated(m))
00650   {
00651     int imin=m.indexmin();
00652     int imax=m.indexmax();
00653     pvm_pkint(&imin,1,1);
00654     pvm_pkint(&imax,1,1);
00655     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00656   }
00657   else
00658   {
00659     int imin=0;
00660     int imax=-1;
00661     pvm_pkint(&imin,1,1);
00662     pvm_pkint(&imax,1,1);
00663   }
00664 }
00665 
00670 void adpvm_pack(const d4_array & _m)
00671 {
00672   d4_array& m = (d4_array &) _m;
00673   if (allocated(m))
00674   {
00675     int imin=m.indexmin();
00676     int imax=m.indexmax();
00677     pvm_pkint(&imin,1,1);
00678     pvm_pkint(&imax,1,1);
00679     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00680   }
00681   else
00682   {
00683     int imin=0;
00684     int imax=-1;
00685     pvm_pkint(&imin,1,1);
00686     pvm_pkint(&imax,1,1);
00687   }
00688 }
00689 
00694 void adpvm_pack(const d5_array & _m)
00695 {
00696   d5_array& m = (d5_array &) _m;
00697   if (allocated(m))
00698   {
00699     int imin=m.indexmin();
00700     int imax=m.indexmax();
00701     pvm_pkint(&imin,1,1);
00702     pvm_pkint(&imax,1,1);
00703     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00704   }
00705   else
00706   {
00707     int imin=0;
00708     int imax=-1;
00709     pvm_pkint(&imin,1,1);
00710     pvm_pkint(&imax,1,1);
00711   }
00712 }
00713 
00718 void adpvm_unpack(const dvector& _v)
00719 {
00720   dvector& v = (dvector&) _v;
00721   int imin;
00722   int imax;
00723   pvm_upkint(&imin,1,1);
00724   pvm_upkint(&imax,1,1);
00725   if (allocated(v)) {
00726     if (v.indexmin()!=imin) {
00727       cerr << "Error in min index in"
00728           " void adpvm_unpack(const dvector& v)" << endl;
00729       ad_exit(1);
00730     }
00731     if (v.indexmax()!=imax) {
00732       cerr << "Error in max index in"
00733           " void adpvm_unpack(const dvector& v)" << endl;
00734       ad_exit(1);
00735     }
00736   } else {
00737     v.allocate(imin,imax);
00738   }
00739   pvm_upkdouble(&(v(imin)),imax-imin+1,1);
00740 }
00741 
00746 void adpvm_unpack(const dmatrix & _m)
00747 {
00748   dmatrix& m = (dmatrix &) _m;
00749   int imin;
00750   int imax;
00751   pvm_upkint(&imin,1,1);
00752   pvm_upkint(&imax,1,1);
00753   if (allocated(m)) {
00754     if (m.indexmin()!=imin) {
00755       cerr << "Error in min index in"
00756           " void adpvm_unpack(const dmatrix& v)" << endl;
00757       ad_exit(1);
00758     }
00759     if (m.indexmax()!=imax) {
00760       cerr << "Error in max index in"
00761           " void adpvm_unpack(const dmatrix& v)" << endl;
00762       ad_exit(1);
00763     }
00764   } else {
00765     m.allocate(imin,imax);
00766   }
00767   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00768 }
00769 
00774 void adpvm_unpack(const d3_array & _m)
00775 {
00776   d3_array& m = (d3_array &) _m;
00777   int imin;
00778   int imax;
00779   pvm_upkint(&imin,1,1);
00780   pvm_upkint(&imax,1,1);
00781   if (allocated(m)) {
00782     if (m.indexmin()!=imin) {
00783       cerr << "Error in min index in"
00784           " void adpvm_unpack(const dvector& v)" << endl;
00785       ad_exit(1);
00786     }
00787     if (m.indexmax()!=imax) {
00788       cerr << "Error in max index in"
00789           " void adpvm_unpack(const dvector& v)" << endl;
00790       ad_exit(1);
00791     }
00792   } else {
00793     m.allocate(imin,imax);
00794   }
00795   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00796 }
00797 
00802 void adpvm_unpack(const d4_array & _m)
00803 {
00804   d4_array& m = (d4_array &) _m;
00805   int imin;
00806   int imax;
00807   pvm_upkint(&imin,1,1);
00808   pvm_upkint(&imax,1,1);
00809   if (allocated(m)) {
00810     if (m.indexmin()!=imin) {
00811       cerr << "Error in min index in"
00812           " void adpvm_unpack(const dvector& v)" << endl;
00813       ad_exit(1);
00814     }
00815     if (m.indexmax()!=imax) {
00816       cerr << "Error in max index in"
00817           " void adpvm_unpack(const dvector& v)" << endl;
00818       ad_exit(1);
00819     }
00820   } else {
00821     m.allocate(imin,imax);
00822   }
00823   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00824 }
00825 
00830 void adpvm_unpack(const d5_array & _m)
00831 {
00832   d5_array& m = (d5_array &) _m;
00833   int imin;
00834   int imax;
00835   pvm_upkint(&imin,1,1);
00836   pvm_upkint(&imax,1,1);
00837   if (allocated(m)) {
00838     if (m.indexmin()!=imin) {
00839       cerr << "Error in min index in"
00840           " void adpvm_unpack(const dvector& v)" << endl;
00841       ad_exit(1);
00842     }
00843     if (m.indexmax()!=imax) {
00844       cerr << "Error in max index in"
00845           " void adpvm_unpack(const dvector& v)" << endl;
00846       ad_exit(1);
00847     }
00848   } else {
00849       m.allocate(imin,imax);
00850   }
00851   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
00852 }
00853 
00858 void adpvm_pack(int v)
00859 {
00860   pvm_pkint(&v,1,1);
00861 }
00862 
00867 void adpvm_pack(const ivector& _v)
00868 {
00869   ivector& v =(ivector&) _v;
00870   int imin=v.indexmin();
00871   int imax=v.indexmax();
00872   pvm_pkint(&imin,1,1);
00873   pvm_pkint(&imax,1,1);
00874   pvm_pkint(&(v(imin)),imax-imin+1,1);
00875 }
00876 
00881 void adpvm_pack(const imatrix & _m)
00882 {
00883   imatrix& m = (imatrix &) _m;
00884   if (allocated(m))
00885   {
00886     int imin=m.indexmin();
00887     int imax=m.indexmax();
00888     pvm_pkint(&imin,1,1);
00889     pvm_pkint(&imax,1,1);
00890     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00891   }
00892   else
00893   {
00894     int imin=0;
00895     int imax=-1;
00896     pvm_pkint(&imin,1,1);
00897     pvm_pkint(&imax,1,1);
00898   }
00899 }
00900 
00905 void adpvm_pack(const i3_array & _m)
00906 {
00907   i3_array& m = (i3_array &) _m;
00908   if (allocated(m))
00909   {
00910     int imin=m.indexmin();
00911     int imax=m.indexmax();
00912     pvm_pkint(&imin,1,1);
00913     pvm_pkint(&imax,1,1);
00914     for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00915   }
00916   else
00917   {
00918     int imin=0;
00919     int imax=-1;
00920     pvm_pkint(&imin,1,1);
00921     pvm_pkint(&imax,1,1);
00922   }
00923 }
00924 /*
00925 void adpvm_pack(const i4_array & _m)
00926 {
00927   i4_array& m = (i4_array &) _m;
00928   int imin=m.indexmin();
00929   int imax=m.indexmax();
00930   pvm_pkint(&imin,1,1);
00931   pvm_pkint(&imax,1,1);
00932   for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00933 }
00934 
00935 void adpvm_pack(const i5_array & _m)
00936 {
00937   i5_array& m = (i5_array &) _m;
00938   int imin=m.indexmin();
00939   int imax=m.indexmax();
00940   pvm_pkint(&imin,1,1);
00941   pvm_pkint(&imax,1,1);
00942   for (int i=imin;i<=imax;i++) adpvm_pack(m(i));
00943 }
00944 */
00945 
00950 void adpvm_unpack(const ivector& _v)
00951 {
00952   ivector& v = (ivector&) _v;
00953   int imin;
00954   int imax;
00955   pvm_upkint(&imin,1,1);
00956   pvm_upkint(&imax,1,1);
00957   if (allocated(v)) {
00958     if (v.indexmin()!=imin) {
00959       cerr << "Error in min index in"
00960           " void adpvm_unpack(const dvector& v)" << endl;
00961       ad_exit(1);
00962     }
00963     if (v.indexmax()!=imax) {
00964       cerr << "Error in max index in"
00965           " void adpvm_unpack(const dvector& v)" << endl;
00966       ad_exit(1);
00967     }
00968   } else {
00969     v.allocate(imin,imax);
00970   }
00971   pvm_upkint(&(v(imin)),imax-imin+1,1);
00972 }
00973 
00978 void adpvm_unpack(const imatrix & _m)
00979 {
00980   imatrix& m = (imatrix &) _m;
00981   int imin;
00982   int imax;
00983   pvm_upkint(&imin,1,1);
00984   pvm_upkint(&imax,1,1);
00985   if (allocated(m)) {
00986     if (m.indexmin()!=imin) {
00987       cerr << "Error in min index in"
00988           "void adpvm_unpack(const imatrix& v)" << endl;
00989       ad_exit(1);
00990     }
00991     if (m.indexmax()!=imax) {
00992       cerr << "Error in max index in"
00993           "void adpvm_unpack(const imatrix& v)" << endl;
00994       ad_exit(1);
00995     }
00996   } else {
00997     m.allocate(imin,imax);
00998   }
00999   for (int i=imin;i<=imax;i++)
01000   {
01001     pvm_unpack(m(i));
01002   }
01003 }
01004 
01009 void adpvm_unpack(const i3_array & _m)
01010 {
01011   i3_array& m = (i3_array &) _m;
01012   int imin;
01013   int imax;
01014   pvm_upkint(&imin,1,1);
01015   pvm_upkint(&imax,1,1);
01016   if (allocated(m)) {
01017     if (m.indexmin()!=imin) {
01018       cerr << "Error in min index in"
01019          "void adpvm_unpack(const i3_array& v)" << endl;
01020       ad_exit(1);
01021     }
01022     if (m.indexmax()!=imax) {
01023       cerr << "Error in max index in"
01024          "void adpvm_unpack(const i3_array& v)" << endl;
01025       ad_exit(1);
01026     }
01027   } else {
01028     m.allocate(imin,imax);
01029   }
01030   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
01031 }
01032 /*
01033 void adpvm_unpack(const i4_array & _m)
01034 {
01035   i4_array& m = (i4_array &) _m;
01036   int imin;
01037   int imax;
01038   pvm_upkint(&imin,1,1);
01039   pvm_upkint(&imax,1,1);
01040   if (allocated(m)) {
01041     if (m.indexmin()!=imin) {
01042       cerr << "Error in min index in
01043           void adpvm_unpack(const dvector& v)" << endl;
01044       ad_exit(1);
01045     }
01046     if (m.indexmax()!=imax) {
01047       cerr << "Error in max index in
01048           void adpvm_unpack(const dvector& v)" << endl;
01049       ad_exit(1);
01050     }
01051   } else {
01052     m.allocate(imin,imax);
01053   }
01054   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
01055 }
01056 
01057 void adpvm_unpack(const i5_array & _m)
01058 {
01059   i5_array& m = (i5_array &) _m;
01060   int imin;
01061   int imax;
01062   pvm_upkint(&imin,1,1);
01063   pvm_upkint(&imax,1,1);
01064   if (allocated(m)) {
01065     if (m.indexmin()!=imin) {
01066       cerr << "Error in min index in
01067           void adpvm_unpack(const dvector& v)" << endl;
01068       ad_exit(1);
01069     }
01070     if (m.indexmax()!=imax) {
01071       cerr << "Error in max index in
01072           void adpvm_unpack(const dvector& v)" << endl;
01073       ad_exit(1);
01074     }
01075   } else {
01076       m.allocate(imin,imax);
01077   }
01078   for (int i=imin;i<=imax;i++) adpvm_unpack(m(i));
01079 }
01080 */
01081 // ************************************************************
01082 // ************************************************************
01083 
01088 void pvm_unpack(const prevariable& _v)
01089 {
01090   dvariable& v = (dvariable&) _v;
01091   pvm_upkdouble((double*)(&(value(v))),1,1);
01092 }
01093 
01098 void pvm_unpack(const double& _v)
01099 {
01100   double& v = (double&) _v;
01101   pvm_upkdouble(&v,1,1);
01102 }
01103 
01108 void pvm_unpack(const int& _v)
01109 {
01110   int& v = (int&) _v;
01111   pvm_upkint(&v,1,1);
01112 }
01113 
01118 void pvm_pack(const dvar_vector& _v)
01119 {
01120   dvar_vector& v =(dvar_vector&) _v;
01121   int imin=v.indexmin();
01122   int imax=v.indexmax();
01123   pvm_pkint(&imin,1,1);
01124   pvm_pkint(&imax,1,1);
01125   pvm_pkdouble(&(value(v(imin))),imax-imin+1,1);
01126 }
01127 
01132 void pvm_pack(const dvar_matrix & _m)
01133 {
01134   dvar_matrix& m = (dvar_matrix &) _m;
01135   if (allocated(m))
01136   {
01137     int imin=m.indexmin();
01138     int imax=m.indexmax();
01139     pvm_pkint(&imin,1,1);
01140     pvm_pkint(&imax,1,1);
01141     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01142   }
01143   else
01144   {
01145     int imin=0;
01146     int imax=-1;
01147     pvm_pkint(&imin,1,1);
01148     pvm_pkint(&imax,1,1);
01149   }
01150 }
01151 
01156 void pvm_pack(const dvar3_array & _m)
01157 {
01158   dvar3_array& m = (dvar3_array &) _m;
01159   if (allocated(m))
01160   {
01161     int imin=m.indexmin();
01162     int imax=m.indexmax();
01163     pvm_pkint(&imin,1,1);
01164     pvm_pkint(&imax,1,1);
01165     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01166   }
01167   else
01168   {
01169     int imin=0;
01170     int imax=-1;
01171     pvm_pkint(&imin,1,1);
01172     pvm_pkint(&imax,1,1);
01173   }
01174 }
01175 
01180 void pvm_pack(const dvar4_array & _m)
01181 {
01182   dvar4_array& m = (dvar4_array &) _m;
01183   if (allocated(m))
01184   {
01185     int imin=m.indexmin();
01186     int imax=m.indexmax();
01187     pvm_pkint(&imin,1,1);
01188     pvm_pkint(&imax,1,1);
01189     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01190   }
01191   else
01192   {
01193     int imin=0;
01194     int imax=-1;
01195     pvm_pkint(&imin,1,1);
01196     pvm_pkint(&imax,1,1);
01197   }
01198 }
01199 
01204 void pvm_pack(const dvar5_array & _m)
01205 {
01206   dvar5_array& m = (dvar5_array &) _m;
01207   if (allocated(m))
01208   {
01209     int imin=m.indexmin();
01210     int imax=m.indexmax();
01211     pvm_pkint(&imin,1,1);
01212     pvm_pkint(&imax,1,1);
01213     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01214   }
01215   else
01216   {
01217     int imin=0;
01218     int imax=-1;
01219     pvm_pkint(&imin,1,1);
01220     pvm_pkint(&imax,1,1);
01221   }
01222 }
01223 
01224 
01225 
01226 void  pvm_end_receive(void) {; }
01227 
01232 void pvm_pack(const prevariable& _v)
01233 {
01234   prevariable& v = (prevariable&) _v;
01235   pvm_pkdouble((double*)(&(value(v))),1,1);
01236 }
01237 
01242 void pvm_unpack(const dvar_vector& _v)
01243 {
01244   dvar_vector& v = (dvar_vector&) _v;
01245   int imin;
01246   int imax;
01247   pvm_upkint(&imin,1,1);
01248   pvm_upkint(&imax,1,1);
01249   if (allocated(v))
01250   {
01251     if (v.indexmin()!=imin)
01252     {
01253       cerr << "Error in min index in "
01254           "void pvm_unpack(const dvar_vector& v)" << endl;
01255       ad_exit(1);
01256     }
01257     if (v.indexmax()!=imax)
01258     {
01259       cerr << "Error in max index in"
01260           " void pvm_unpack(const dvar_vector& v)" << endl;
01261       ad_exit(1);
01262     }
01263   }
01264   else
01265   {
01266     v.allocate(imin,imax);
01267   }
01268   pvm_upkdouble(&(value(v(imin))),imax-imin+1,1);
01269 }
01270 
01275 void pvm_unpack(const dvar_matrix & _m)
01276 {
01277   dvar_matrix& m = (dvar_matrix &) _m;
01278   int imin;
01279   int imax;
01280   pvm_upkint(&imin,1,1);
01281   pvm_upkint(&imax,1,1);
01282   if (allocated(m)) {
01283     if (m.indexmin()!=imin) {
01284       cerr << "Error in min index in"
01285           " void pvm_unpack(const dvar_matrix& v)" << endl;
01286       ad_exit(1);
01287     }
01288     if (m.indexmax()!=imax) {
01289       cerr << "Error in max index in"
01290           " void pvm_unpack(const dvar_matrix& v)" << endl;
01291       ad_exit(1);
01292     }
01293   } else {
01294     m.allocate(imin,imax);
01295   }
01296   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01297 }
01298 
01303 void pvm_unpack(const dvar3_array & _m)
01304 {
01305   dvar3_array & m = (dvar3_array &) _m;
01306   int imin;
01307   int imax;
01308   pvm_upkint(&imin,1,1);
01309   pvm_upkint(&imax,1,1);
01310   if (allocated(m)) {
01311     if (m.indexmin()!=imin) {
01312       cerr << "Error in min index in"
01313           " void pvm_unpack(const dvar_3array& v)" << endl;
01314       ad_exit(1);
01315     }
01316     if (m.indexmax()!=imax) {
01317       cerr << "Error in max index in"
01318           " void pvm_unpack(const dvar3_array& v)" << endl;
01319       ad_exit(1);
01320     }
01321   } else {
01322     m.allocate(imin,imax);
01323   }
01324   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01325 }
01326 
01331 void pvm_unpack(const dvar4_array & _m)
01332 {
01333   dvar4_array& m = (dvar4_array &) _m;
01334   int imin;
01335   int imax;
01336   pvm_upkint(&imin,1,1);
01337   pvm_upkint(&imax,1,1);
01338   if (allocated(m)) {
01339     if (m.indexmin()!=imin) {
01340       cerr << "Error in min index in"
01341           " void pvm_unpack(const dvector& v)" << endl;
01342       ad_exit(1);
01343     }
01344     if (m.indexmax()!=imax) {
01345       cerr << "Error in max index in"
01346           " void pvm_unpack(const dvector& v)" << endl;
01347       ad_exit(1);
01348     }
01349   } else {
01350     m.allocate(imin,imax);
01351   }
01352   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01353 }
01354 
01359 void pvm_unpack(const dvar5_array & _m)
01360 {
01361   dvar5_array& m = (dvar5_array &) _m;
01362   int imin;
01363   int imax;
01364   pvm_upkint(&imin,1,1);
01365   pvm_upkint(&imax,1,1);
01366   if (allocated(m)) {
01367     if (m.indexmin()!=imin) {
01368       cerr << "Error in min index in"
01369           " void pvm_unpack(const dvector& v)" << endl;
01370       ad_exit(1);
01371     }
01372     if (m.indexmax()!=imax) {
01373       cerr << "Error in max index in"
01374           " void pvm_unpack(const dvector& v)" << endl;
01375       ad_exit(1);
01376     }
01377   } else {
01378       m.allocate(imin,imax);
01379   }
01380   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01381 }
01382 
01387 void pvm_pack(double v)
01388 {
01389   pvm_pkdouble(&v,1,1);
01390 }
01391 
01396 void pvm_pack(const dvector& _v)
01397 {
01398   dvector& v =(dvector&) _v;
01399   if (allocated(v))
01400   {
01401     int imin=v.indexmin();
01402     int imax=v.indexmax();
01403     pvm_pkint(&imin,1,1);
01404     pvm_pkint(&imax,1,1);
01405     pvm_pkdouble(&(v(imin)),imax-imin+1,1);
01406   }
01407   else
01408   {
01409     int imin=0;
01410     int imax=-1;
01411     pvm_pkint(&imin,1,1);
01412     pvm_pkint(&imax,1,1);
01413   }
01414 }
01415 
01420 void pvm_pack(const dmatrix & _m)
01421 {
01422   dmatrix& m = (dmatrix &) _m;
01423   if (allocated(m))
01424   {
01425     int imin=m.indexmin();
01426     int imax=m.indexmax();
01427     pvm_pkint(&imin,1,1);
01428     pvm_pkint(&imax,1,1);
01429     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01430   }
01431   else
01432   {
01433     int imin=0;
01434     int imax=-1;
01435     pvm_pkint(&imin,1,1);
01436     pvm_pkint(&imax,1,1);
01437   }
01438 }
01439 
01444 void pvm_pack(const d3_array & _m)
01445 {
01446   d3_array& m = (d3_array &) _m;
01447   if (allocated(m))
01448   {
01449     int imin=m.indexmin();
01450     int imax=m.indexmax();
01451     pvm_pkint(&imin,1,1);
01452     pvm_pkint(&imax,1,1);
01453     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01454   }
01455   else
01456   {
01457     int imin=0;
01458     int imax=-1;
01459     pvm_pkint(&imin,1,1);
01460     pvm_pkint(&imax,1,1);
01461   }
01462 }
01463 
01468 void pvm_pack(const d4_array & _m)
01469 {
01470   d4_array& m = (d4_array &) _m;
01471   if (allocated(m))
01472   {
01473     int imin=m.indexmin();
01474     int imax=m.indexmax();
01475     pvm_pkint(&imin,1,1);
01476     pvm_pkint(&imax,1,1);
01477     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01478   }
01479   else
01480   {
01481     int imin=0;
01482     int imax=-1;
01483     pvm_pkint(&imin,1,1);
01484     pvm_pkint(&imax,1,1);
01485   }
01486 }
01487 
01492 void pvm_pack(const d5_array & _m)
01493 {
01494   d5_array& m = (d5_array &) _m;
01495   if (allocated(m))
01496   {
01497     int imin=m.indexmin();
01498     int imax=m.indexmax();
01499     pvm_pkint(&imin,1,1);
01500     pvm_pkint(&imax,1,1);
01501     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01502   }
01503   else
01504   {
01505     int imin=0;
01506     int imax=-1;
01507     pvm_pkint(&imin,1,1);
01508     pvm_pkint(&imax,1,1);
01509   }
01510 }
01511 
01516 void pvm_unpack(const dvector& _v)
01517 {
01518   dvector& v = (dvector&) _v;
01519   int imin;
01520   int imax;
01521   pvm_upkint(&imin,1,1);
01522   pvm_upkint(&imax,1,1);
01523   if (allocated(v)) {
01524     if (v.indexmin()!=imin) {
01525       cerr << "Error in min index in"
01526           " void pvm_unpack(const dvector& v)" << endl;
01527       ad_exit(1);
01528     }
01529     if (v.indexmax()!=imax) {
01530       cerr << "Error in max index in"
01531           " void pvm_unpack(const dvector& v)" << endl;
01532       ad_exit(1);
01533     }
01534   } else {
01535     v.allocate(imin,imax);
01536   }
01537   pvm_upkdouble(&(v(imin)),imax-imin+1,1);
01538 }
01539 
01544 void pvm_unpack(const dmatrix & _m)
01545 {
01546   dmatrix& m = (dmatrix &) _m;
01547   int imin;
01548   int imax;
01549   pvm_upkint(&imin,1,1);
01550   pvm_upkint(&imax,1,1);
01551   if (allocated(m)) {
01552     if (m.indexmin()!=imin) {
01553       cerr << "Error in min index in"
01554           " void pvm_unpack(const dmatrix& v)" << endl;
01555       ad_exit(1);
01556     }
01557     if (m.indexmax()!=imax) {
01558       cerr << "Error in max index in"
01559           " void pvm_unpack(const dmatrix& v)" << endl;
01560       ad_exit(1);
01561     }
01562   } else {
01563     m.allocate(imin,imax);
01564   }
01565   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01566 }
01567 
01572 void pvm_unpack(const d3_array & _m)
01573 {
01574   d3_array& m = (d3_array &) _m;
01575   int imin;
01576   int imax;
01577   pvm_upkint(&imin,1,1);
01578   pvm_upkint(&imax,1,1);
01579   if (allocated(m)) {
01580     if (m.indexmin()!=imin) {
01581       cerr << "Error in min index in"
01582           " void pvm_unpack(const dvector& v)" << endl;
01583       ad_exit(1);
01584     }
01585     if (m.indexmax()!=imax) {
01586       cerr << "Error in max index in"
01587           " void pvm_unpack(const dvector& v)" << endl;
01588       ad_exit(1);
01589     }
01590   } else {
01591     m.allocate(imin,imax);
01592   }
01593   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01594 }
01595 
01600 void pvm_unpack(const d4_array & _m)
01601 {
01602   d4_array& m = (d4_array &) _m;
01603   int imin;
01604   int imax;
01605   pvm_upkint(&imin,1,1);
01606   pvm_upkint(&imax,1,1);
01607   if (allocated(m)) {
01608     if (m.indexmin()!=imin) {
01609       cerr << "Error in min index in"
01610           " void pvm_unpack(const dvector& v)" << endl;
01611       ad_exit(1);
01612     }
01613     if (m.indexmax()!=imax) {
01614       cerr << "Error in max index in"
01615           " void pvm_unpack(const dvector& v)" << endl;
01616       ad_exit(1);
01617     }
01618   } else {
01619     m.allocate(imin,imax);
01620   }
01621   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01622 }
01623 
01628 void pvm_unpack(const d5_array & _m)
01629 {
01630   d5_array& m = (d5_array &) _m;
01631   int imin;
01632   int imax;
01633   pvm_upkint(&imin,1,1);
01634   pvm_upkint(&imax,1,1);
01635   if (allocated(m)) {
01636     if (m.indexmin()!=imin) {
01637       cerr << "Error in min index in"
01638           " void pvm_unpack(const dvector& v)" << endl;
01639       ad_exit(1);
01640     }
01641     if (m.indexmax()!=imax) {
01642       cerr << "Error in max index in"
01643           " void pvm_unpack(const dvector& v)" << endl;
01644       ad_exit(1);
01645     }
01646   } else {
01647       m.allocate(imin,imax);
01648   }
01649   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01650 }
01651 
01656 void pvm_pack(int v)
01657 {
01658   pvm_pkint(&v,1,1);
01659 }
01660 
01665 void pvm_pack(const ivector& _v)
01666 {
01667   ivector& v =(ivector&) _v;
01668   int imin=v.indexmin();
01669   int imax=v.indexmax();
01670   pvm_pkint(&imin,1,1);
01671   pvm_pkint(&imax,1,1);
01672   pvm_pkint(&(v(imin)),imax-imin+1,1);
01673 }
01674 
01679 void pvm_pack(const imatrix & _m)
01680 {
01681   imatrix& m = (imatrix &) _m;
01682   if (allocated(m))
01683   {
01684     int imin=m.indexmin();
01685     int imax=m.indexmax();
01686     pvm_pkint(&imin,1,1);
01687     pvm_pkint(&imax,1,1);
01688     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01689   }
01690   else
01691   {
01692     int imin=0;
01693     int imax=-1;
01694     pvm_pkint(&imin,1,1);
01695     pvm_pkint(&imax,1,1);
01696   }
01697 }
01698 
01703 void pvm_pack(const i3_array & _m)
01704 {
01705   i3_array& m = (i3_array &) _m;
01706   if (allocated(m))
01707   {
01708     int imin=m.indexmin();
01709     int imax=m.indexmax();
01710     pvm_pkint(&imin,1,1);
01711     pvm_pkint(&imax,1,1);
01712     for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01713   }
01714   else
01715   {
01716     int imin=0;
01717     int imax=-1;
01718     pvm_pkint(&imin,1,1);
01719     pvm_pkint(&imax,1,1);
01720   }
01721 }
01722 /*
01723 void pvm_pack(const i4_array & _m)
01724 {
01725   i4_array& m = (i4_array &) _m;
01726   int imin=m.indexmin();
01727   int imax=m.indexmax();
01728   pvm_pkint(&imin,1,1);
01729   pvm_pkint(&imax,1,1);
01730   for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01731 }
01732 
01733 void pvm_pack(const i5_array & _m)
01734 {
01735   i5_array& m = (i5_array &) _m;
01736   int imin=m.indexmin();
01737   int imax=m.indexmax();
01738   pvm_pkint(&imin,1,1);
01739   pvm_pkint(&imax,1,1);
01740   for (int i=imin;i<=imax;i++) pvm_pack(m(i));
01741 }
01742 */
01743 
01748 void pvm_unpack(const ivector& _v)
01749 {
01750   ivector& v = (ivector&) _v;
01751   int imin;
01752   int imax;
01753   pvm_upkint(&imin,1,1);
01754   pvm_upkint(&imax,1,1);
01755   if (allocated(v)) {
01756     if (v.indexmin()!=imin) {
01757       cerr << "Error in min index in"
01758           " void pvm_unpack(const dvector& v)" << endl;
01759       ad_exit(1);
01760     }
01761     if (v.indexmax()!=imax) {
01762       cerr << "Error in max index in"
01763           " void pvm_unpack(const dvector& v)" << endl;
01764       ad_exit(1);
01765     }
01766   } else {
01767     v.allocate(imin,imax);
01768   }
01769   pvm_upkint(&(v(imin)),imax-imin+1,1);
01770 }
01771 
01776 void pvm_unpack(const imatrix & _m)
01777 {
01778   imatrix& m = (imatrix &) _m;
01779   int imin;
01780   int imax;
01781   pvm_upkint(&imin,1,1);
01782   pvm_upkint(&imax,1,1);
01783   if (allocated(m)) {
01784     if (m.indexmin()!=imin) {
01785       cerr << "Error in min index in"
01786           "void pvm_unpack(const imatrix& v)" << endl;
01787       ad_exit(1);
01788     }
01789     if (m.indexmax()!=imax) {
01790       cerr << "Error in max index in"
01791           "void pvm_unpack(const imatrix& v)" << endl;
01792       ad_exit(1);
01793     }
01794   } else {
01795     m.allocate(imin,imax);
01796   }
01797   for (int i=imin;i<=imax;i++)
01798   {
01799     pvm_unpack(m(i));
01800   }
01801 }
01802 
01807 void pvm_unpack(const i3_array & _m)
01808 {
01809   i3_array& m = (i3_array &) _m;
01810   int imin;
01811   int imax;
01812   pvm_upkint(&imin,1,1);
01813   pvm_upkint(&imax,1,1);
01814   if (allocated(m)) {
01815     if (m.indexmin()!=imin) {
01816       cerr << "Error in min index in"
01817          "void pvm_unpack(const i3_array& v)" << endl;
01818       ad_exit(1);
01819     }
01820     if (m.indexmax()!=imax) {
01821       cerr << "Error in max index in"
01822          "void pvm_unpack(const i3_array& v)" << endl;
01823       ad_exit(1);
01824     }
01825   } else {
01826     m.allocate(imin,imax);
01827   }
01828   for (int i=imin;i<=imax;i++) pvm_unpack(m(i));
01829 }
01830 
01835 int adpvm_slave_vinitsend(int mode)
01836 {
01837   return adpvm_initsend(mode);
01838 }
01839 
01844 int adpvm_slave_cinitsend(int mode)
01845 {
01846   return adpvm_initsend(mode);
01847 }
01848 
01853 void adpvm_slave_vsend(int ptid)
01854 {
01855   adpvm_send(ptid, 2);
01856 }
01857 
01862 void adpvm_slave_csend(int ptid)
01863 {
01864   ad_constant_flag=1;
01865   adpvm_send(ptid, 2);
01866   ad_constant_flag=0;
01867 }
01868 
01873 int adpvm_slave_vrecv(int ptid)
01874 {
01875   int ierr=pvm_recv(ptid,-1);
01876   adpvm_unpack(gradient_structure::no_derivatives);
01877 
01878   if (!gradient_structure::no_derivatives)
01879   {
01880     save_identifier_string("E");
01881     save_int_value(ptid);
01882     save_int_value(2);
01883     save_identifier_string("F");
01884     gradient_structure::GRAD_STACK1->
01885             set_gradient_stack(adpvm_send_derivatives);
01886   }
01887 
01888   return ierr;
01889 }
01890 
01895 int adpvm_slave_crecv(int ptid)
01896 {
01897   ad_constant_flag=1;
01898   int ierr=adpvm_recv(ptid,-1);
01899   ad_constant_flag=0;
01900   return ierr;
01901 }
01902 
01907 int adpvm_master_vinitsend(int mode)
01908 {
01909   int bufid = adpvm_initsend(mode);
01910   adpvm_pack(gradient_structure::no_derivatives);
01911   return bufid;
01912 }
01913 
01918 int adpvm_master_cinitsend(int mode)
01919 {
01920   int bufid = adpvm_initsend(mode);
01921   return bufid;
01922 }
01923 
01928 void adpvm_master_csend(int id)
01929 {
01930   ad_constant_flag=1;
01931   adpvm_send(id,1);
01932   ad_constant_flag=0;
01933 }
01934 
01939 void adpvm_master_vsend(int id)
01940 {
01941   adpvm_send(id,1);
01942 }
01943 
01948 int adpvm_master_vrecv(int id)
01949 {
01950   return adpvm_recv(id,2);
01951 }
01952 int adpvm_master_crecv(int id)
01953 {
01954   ad_constant_flag=1;
01955   int status=adpvm_recv(id,2);
01956   ad_constant_flag=0;
01957   return status;
01958 }
01959 
01964 void  adpvm_master_end_vreceive(void)
01965 {
01966   adpvm_end_receive();
01967 }
01968 
01973 void  adpvm_slave_end_vreceive(void)
01974 {
01975   adpvm_end_receive();
01976 }
01977 
01978 void  adpvm_master_end_creceive(void) { }
01979 
01980 void  adpvm_slave_end_creceive(void) { }
01981 
01986 dvar_vector get_x_from_master(void)
01987 {
01988   dvar_vector x;
01989   int ptid=pvm_parent();
01990   // ***************  begin variable receive block *********************
01991   adpvm_slave_vrecv(ptid);
01992   adpvm_unpack(x);
01993   adpvm_slave_end_vreceive();
01994   // ***************  end receive block ***********************************
01995   return x;
01996 }
01997 
02002 dvector get_dvector_from_master(void)
02003 {
02004   dvector x;
02005   int ptid=pvm_parent();
02006   // ***************  begin variable receive block *********************
02007   adpvm_slave_crecv(ptid);
02008   adpvm_unpack(x);
02009   adpvm_slave_end_creceive();
02010   // ***************  end receive block ***********************************
02011   return x;
02012 }
02013 
02018 dmatrix get_dmatrix_from_master(void)
02019 {
02020   dmatrix x;
02021   int ptid=pvm_parent();
02022   // ***************  begin variable receive block *********************
02023   adpvm_slave_crecv(ptid);
02024   adpvm_unpack(x);
02025   adpvm_slave_end_creceive();
02026   // ***************  end receive block ***********************************
02027   return x;
02028 }
02029 
02034 void send_f_to_master(const dvariable& f)
02035 {
02036   // ***************  begin send block ***********************************
02037   int ptid=pvm_parent();
02038   adpvm_slave_vinitsend(PvmDataDefault);/* allocate message buffer */ 
02039   adpvm_pack(f);
02040   adpvm_slave_vsend(ptid);/* send buffer to master */
02041   // ***************  end send block ***********************************
02042 }
02043 
02048 void send_dv3_to_master(const dvar3_array& v)
02049 {
02050   // ***************  begin send block ***********************************
02051   int ptid=pvm_parent();
02052   adpvm_slave_vinitsend(PvmDataDefault);/* allocate message buffer */ 
02053   adpvm_pack(v);
02054   adpvm_slave_vsend(ptid);/* send buffer to master */
02055   // ***************  end send block ***********************************
02056 }
02057 
02062 void send_dvector_to_master(const dvector& v)
02063 {
02064   // ***************  begin send block ***********************************
02065   int ptid=pvm_parent();
02066   adpvm_slave_cinitsend(PvmDataDefault);/* allocate message buffer */ 
02067   adpvm_pack(v);
02068   adpvm_slave_csend(ptid);/* send buffer to master */
02069   // ***************  end send block ***********************************
02070 }
02071 #endif //#if defined(USE_ADPVM)
02072 #endif