/[escript]/branches/schroedinger/escript/test/DataTestCase.cpp
ViewVC logotype

Diff of /branches/schroedinger/escript/test/DataTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1937 by jfenwick, Mon Oct 27 06:06:39 2008 UTC revision 1938 by jfenwick, Tue Oct 28 01:51:08 2008 UTC
# Line 730  void DataTestCase::testConstructors() { Line 730  void DataTestCase::testConstructors() {
730    }    }
731  }  }
732    
733  void DataTestCase::testOperations() {  
734    void DataTestCase::testOperations()
735    {
736    
737    cout << endl;    cout << endl;
738    
# Line 749  void DataTestCase::testOperations() { Line 751  void DataTestCase::testOperations() {
751      }      }
752    }    }
753    
754    
755    
756    Data dats[]={Data(data,shape,FunctionSpace(),false),    Data dats[]={Data(data,shape,FunctionSpace(),false),
757          Data(data,shape,FunctionSpace(),false),          Data(data,shape,FunctionSpace(),false),
758            Data(data,shape,FunctionSpace(),true),
759            Data(data,shape,FunctionSpace(),false),
760            Data(data,shape,FunctionSpace(),false),
761          Data(data,shape,FunctionSpace(),true)};          Data(data,shape,FunctionSpace(),true)};
762    const int NUMDATS=3;    const int NUMDATS=6;
763      const int LAZY=3;     // where do the lazy objects start?
764    
765  //   Data baseEx(data,shape,FunctionSpace(),true);  //   Data baseEx(data,shape,FunctionSpace(),true);
766  //   Data baseCon(data,shape,FunctionSpace(),false);  //   Data baseCon(data,shape,FunctionSpace(),false);
# Line 761  void DataTestCase::testOperations() { Line 769  void DataTestCase::testOperations() {
769    Data& baseTag=dats[1];    Data& baseTag=dats[1];
770    Data& baseEx=dats[2];    Data& baseEx=dats[2];
771    baseTag.tag();    baseTag.tag();
772      dats[4].tag();
773      dats[3].delaySelf();
774      dats[4].delaySelf();
775      dats[5].delaySelf();
776    
777    assert(baseEx.isExpanded());    assert(baseEx.isExpanded());
778    assert(baseCon.isConstant());    assert(baseCon.isConstant());
# Line 771  void DataTestCase::testOperations() { Line 783  void DataTestCase::testOperations() {
783    Data& resultCon=results[1];    Data& resultCon=results[1];
784    Data& resultTag=results[2];    Data& resultTag=results[2];
785    
786      // create 0 <= smalldata <= 1 for testing trig functions
787    
788      DataTypes::ValueType smalldata(DataTypes::noValues(shape),0);
789    
790      // assign values to the data
791      for (int i=0;i<shape[0];i++) {
792        for (int j=0;j<shape[1];j++) {
793          smalldata[getRelIndex(shape,i,j)]=(i==0 && j==0)?0:1.0/(getRelIndex(shape,i,j)+1);
794        }
795      }
796      Data sdats[]={Data(smalldata,shape,FunctionSpace(),false),
797            Data(smalldata,shape,FunctionSpace(),false),
798            Data(smalldata,shape,FunctionSpace(),true),
799            Data(smalldata,shape,FunctionSpace(),false),
800            Data(smalldata,shape,FunctionSpace(),false),
801            Data(smalldata,shape,FunctionSpace(),true)};
802      sdats[1].tag();
803      sdats[4].tag();
804      sdats[3].delaySelf();
805      sdats[4].delaySelf();
806      sdats[5].delaySelf();
807    
808    
809    
810    // test unary operations    // test unary operations
811    
812    double tmp;    double tmp;
# Line 779  void DataTestCase::testOperations() { Line 815  void DataTestCase::testOperations() {
815    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
816    {    {
817      results[z].copy(dats[z].powD(power));      results[z].copy(dats[z].powD(power));
818        if (z>=LAZY)
819        {
820        assert(results[z].isLazy());
821        }
822    }    }
823    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
824      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 794  void DataTestCase::testOperations() { Line 834  void DataTestCase::testOperations() {
834    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
835    {    {
836      results[z].copy(dats[z].sin());      results[z].copy(dats[z].sin());
837        if (z>=LAZY)
838        {
839        assert(results[z].isLazy());
840        }
841    }    }
842    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
843      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 809  void DataTestCase::testOperations() { Line 853  void DataTestCase::testOperations() {
853    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
854    {    {
855      results[z].copy(dats[z].cos());      results[z].copy(dats[z].cos());
856        if (z>=LAZY)
857        {
858        assert(results[z].isLazy());
859        }
860    }    }
861    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
862      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 824  void DataTestCase::testOperations() { Line 872  void DataTestCase::testOperations() {
872    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
873    {    {
874      results[z].copy(dats[z].tan());      results[z].copy(dats[z].tan());
875        if (z>=LAZY)
876        {
877        assert(results[z].isLazy());
878        }
879    }    }
880    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
881      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 838  void DataTestCase::testOperations() { Line 890  void DataTestCase::testOperations() {
890    cout << "\tTest Data::asin." << endl;    cout << "\tTest Data::asin." << endl;
891    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
892    {    {
893      results[z].copy(dats[z].asin());      results[z].copy(sdats[z].asin());
894        if (z>=LAZY)
895        {
896        assert(results[z].isLazy());
897        }
898      }
899      for (int i=0;i<shape[0];i++) {
900        for (int j=0;j<shape[1];j++) {
901          tmp=asin((double)smalldata[getRelIndex(shape,i,j)]);
902          for (int z=0;z<NUMDATS;++z)
903          {
904        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
905          }
906        }
907    }    }
   assert(true);  
908    
909    cout << "\tTest Data::acos." << endl;    cout << "\tTest Data::acos." << endl;
910    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
911    {    {
912      results[z].copy(dats[z].asin());      results[z].copy(sdats[z].acos());
913        if (z>=LAZY)
914        {
915        assert(results[z].isLazy());
916        }
917      }
918      for (int i=0;i<shape[0];i++) {
919        for (int j=0;j<shape[1];j++) {
920          tmp=acos((double)smalldata[getRelIndex(shape,i,j)]);
921          for (int z=0;z<NUMDATS;++z)
922          {
923        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
924          }
925        }
926    }    }
   assert(true);  
927    
928    cout << "\tTest Data::atan." << endl;    cout << "\tTest Data::atan." << endl;
929    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
930    {    {
931      results[z].copy(dats[z].atan());      results[z].copy(sdats[z].atan());
932        if (z>=LAZY)
933        {
934        assert(results[z].isLazy());
935        }
936    }    }
937    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
938      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
939        tmp=atan((double)data[getRelIndex(shape,i,j)]);        tmp=atan((double)smalldata[getRelIndex(shape,i,j)]);
940        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
941        {        {
942      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
# Line 868  void DataTestCase::testOperations() { Line 948  void DataTestCase::testOperations() {
948    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
949    {    {
950      results[z].copy(dats[z].sinh());      results[z].copy(dats[z].sinh());
951        if (z>=LAZY)
952        {
953        assert(results[z].isLazy());
954        }
955    }    }
956    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
957      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 883  void DataTestCase::testOperations() { Line 967  void DataTestCase::testOperations() {
967    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
968    {    {
969      results[z].copy(dats[z].cosh());      results[z].copy(dats[z].cosh());
970        if (z>=LAZY)
971        {
972        assert(results[z].isLazy());
973        }
974    }    }
975    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
976      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 898  void DataTestCase::testOperations() { Line 986  void DataTestCase::testOperations() {
986    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
987    {    {
988      results[z].copy(dats[z].tanh());      results[z].copy(dats[z].tanh());
989        if (z>=LAZY)
990        {
991        assert(results[z].isLazy());
992        }
993    }    }
994    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
995      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 909  void DataTestCase::testOperations() { Line 1001  void DataTestCase::testOperations() {
1001      }      }
1002    }    }
1003    
1004      // rather than accomodate the different windows operations directly I'll just use inverse functions
1005    cout << "\tTest Data::asinh." << endl;    cout << "\tTest Data::asinh." << endl;
1006    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1007    {    {
1008      results[z].copy(dats[z].asinh());      results[z].copy(dats[z].asinh().sinh());
1009        if (z>=LAZY)
1010        {
1011        assert(results[z].isLazy());
1012        }
1013      }
1014      for (int i=0;i<shape[0];i++) {
1015        for (int j=0;j<shape[1];j++) {
1016          tmp=data[getRelIndex(shape,i,j)];
1017          for (int z=0;z<NUMDATS;++z)
1018          {
1019        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1020          }
1021        }
1022    }    }
   assert(true);  
1023    
1024    cout << "\tTest Data::acosh." << endl;    cout << "\tTest Data::acosh." << endl;
1025    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1026    {    {
1027      results[z].copy(dats[z].acosh());      results[z].copy(dats[z].acosh().cosh());
1028        if (z>=LAZY)
1029        {
1030        assert(results[z].isLazy());
1031        }
1032      }
1033      for (int i=0;i<shape[0];i++) {
1034        for (int j=0;j<shape[1];j++) {
1035          if (i==0 && j==0) break;
1036          tmp=data[getRelIndex(shape,i,j)];
1037          for (int z=0;z<NUMDATS;++z)
1038          {
1039        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1040          }
1041        }
1042    }    }
   assert(true);  
1043    
1044    cout << "\tTest Data::atanh." << endl;    cout << "\tTest Data::atanh." << endl;
1045    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1046    {    {
1047      results[z].copy(dats[z].atanh());      results[z].copy(dats[z].tanh().atanh());        // if these are the other way around the results are
1048        if (z>=LAZY)                    // undefined
1049        {
1050        assert(results[z].isLazy());
1051        }
1052      }
1053      for (int i=0;i<shape[0];i++) {
1054        for (int j=0;j<shape[1];j++) {
1055          tmp=data[getRelIndex(shape,i,j)];
1056          for (int z=0;z<NUMDATS;++z)
1057          {
1058        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1059          }
1060        }
1061    }    }
   assert(true);  
1062    
1063    cout << "\tTest Data::log." << endl;    cout << "\tTest Data::log." << endl;
1064    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1065    {    {
1066      results[z].copy(dats[z].log());      results[z].copy(dats[z].log());
1067        if (z>=LAZY)
1068        {
1069        assert(results[z].isLazy());
1070        }
1071      }
1072      for (int i=0;i<shape[0];i++) {
1073        for (int j=0;j<shape[1];j++) {
1074          if (i==0 && j==0) break;
1075          tmp=log((double)data[getRelIndex(shape,i,j)]);
1076          for (int z=0;z<NUMDATS;++z)
1077          {
1078        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1079          }
1080        }
1081      }
1082    
1083      cout << "\tTest Data::log10." << endl;
1084      for (int z=0;z<NUMDATS;++z)
1085      {
1086        results[z].copy(dats[z].log10());
1087        if (z>=LAZY)
1088        {
1089        assert(results[z].isLazy());
1090        }
1091    }    }
1092    assert(true);    for (int i=0;i<shape[0];i++) {
1093        for (int j=0;j<shape[1];j++) {
1094          if (i==0 && j==0) break;
1095          tmp=log10((double)data[getRelIndex(shape,i,j)]);
1096          for (int z=0;z<NUMDATS;++z)
1097          {
1098        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1099          }
1100        }
1101      }
1102    #ifndef _WIN32
1103      cout << "\tTest Data::erf." << endl;
1104      for (int z=0;z<NUMDATS;++z)
1105      {
1106        results[z].copy(dats[z].erf());
1107        if (z>=LAZY)
1108        {
1109        assert(results[z].isLazy());
1110        }
1111      }
1112      for (int i=0;i<shape[0];i++) {
1113        for (int j=0;j<shape[1];j++) {
1114          if (i==0 && j==0) break;
1115          tmp=erf((double)data[getRelIndex(shape,i,j)]);
1116          for (int z=0;z<NUMDATS;++z)
1117          {
1118        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1119          }
1120        }
1121      }
1122    #endif
1123    
1124    
1125    cout << "\tTest Data::abs." << endl;    cout << "\tTest Data::abs." << endl;
1126    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1127    {    {
1128      results[z].copy(dats[z].abs());      results[z].copy(dats[z].abs());
1129        if (z>=LAZY)
1130        {
1131        assert(results[z].isLazy());
1132        }
1133    }    }
1134    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1135      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 952  void DataTestCase::testOperations() { Line 1141  void DataTestCase::testOperations() {
1141      }      }
1142    }    }
1143    
1144    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign (positive)." << endl;
1145    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1146    {    {
1147      results[z].copy(dats[z].sign());      results[z].copy(dats[z].sign());
1148        if (z>=LAZY)
1149        {
1150        assert(results[z].isLazy());
1151        }
1152      }
1153      for (int i=0;i<shape[0];i++) {
1154        for (int j=0;j<shape[1];j++) {
1155          tmp=(i==0 && j==0)?0:1;
1156          for (int z=0;z<NUMDATS;++z)
1157          {
1158        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1159          }
1160        }
1161      }
1162    
1163      cout << "\tTest Data::sign (negative)." << endl;
1164      for (int z=0;z<NUMDATS;++z)
1165      {
1166        results[z].copy(dats[z].neg().sign());
1167        if (z>=LAZY)
1168        {
1169        assert(results[z].isLazy());
1170        }
1171    }    }
1172    assert(true);    for (int i=0;i<shape[0];i++) {
1173        for (int j=0;j<shape[1];j++) {
1174          tmp=(i==0 && j==0)?0:-1;
1175          for (int z=0;z<NUMDATS;++z)
1176          {
1177        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1178          }
1179        }
1180      }
1181    
1182    
1183    cout << "\tTest Data::exp." << endl;    cout << "\tTest Data::exp." << endl;
1184    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1185    {    {
1186      results[z].copy(dats[z].exp());      results[z].copy(dats[z].exp());
1187        if (z>=LAZY)
1188        {
1189        assert(results[z].isLazy());
1190        }
1191    }    }
1192    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1193      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 978  void DataTestCase::testOperations() { Line 1203  void DataTestCase::testOperations() {
1203    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1204    {    {
1205      results[z].copy(dats[z].sqrt());      results[z].copy(dats[z].sqrt());
1206        if (z>=LAZY)
1207        {
1208        assert(results[z].isLazy());
1209        }
1210    }    }
1211    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1212      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 993  void DataTestCase::testOperations() { Line 1222  void DataTestCase::testOperations() {
1222    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1223    {    {
1224      results[z].copy(dats[z].neg());      results[z].copy(dats[z].neg());
1225        if (z>=LAZY)
1226        {
1227        assert(results[z].isLazy());
1228        }
1229      }
1230      for (int i=0;i<shape[0];i++) {
1231        for (int j=0;j<shape[1];j++) {
1232          tmp=-data[getRelIndex(shape,i,j)];
1233          for (int z=0;z<NUMDATS;++z)
1234          {
1235        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1236          }
1237        }
1238    }    }
   assert(true);  
1239    
1240    cout << "\tTest Data::pos." << endl;    cout << "\tTest Data::pos." << endl;
1241    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1242    {    {
1243      results[z].copy(dats[z].pos());      results[z].copy(dats[z].pos());
1244        if (z>=LAZY)
1245        {
1246        assert(results[z].isLazy());
1247        }
1248    }    }
1249    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1250      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
# Line 1056  void DataTestCase::testOperations() { Line 1301  void DataTestCase::testOperations() {
1301  }  }
1302    
1303    
1304    // Here we test the binary operators in complex expressions
1305    void DataTestCase::testBinary()
1306    {
1307    
1308      cout << endl;
1309    
1310      // define the shape for the test data
1311      DataTypes::ShapeType shape;
1312      shape.push_back(2);
1313      shape.push_back(3);
1314    
1315      // allocate the data
1316      DataTypes::ValueType data(DataTypes::noValues(shape),0);
1317    
1318      // assign values to the data
1319      for (int i=0;i<shape[0];i++) {
1320        for (int j=0;j<shape[1];j++) {
1321          data[getRelIndex(shape,i,j)]=getRelIndex(shape,i,j)+2;    // so we get no zeros
1322        }
1323      }
1324    
1325    
1326      Data one(1.0,DataTypes::scalarShape,FunctionSpace());
1327      Data two(2.0,DataTypes::scalarShape,FunctionSpace());
1328      Data dats[]={Data(data,shape,FunctionSpace(),false),
1329            Data(data,shape,FunctionSpace(),false),
1330            Data(data,shape,FunctionSpace(),true),
1331            Data(data,shape,FunctionSpace(),false),
1332            Data(data,shape,FunctionSpace(),false),
1333            Data(data,shape,FunctionSpace(),true)};
1334      dats[1].tag();
1335      dats[4].tag();
1336      const int NUMDATS=6;
1337      const int LAZY=3;
1338      dats[3].delaySelf();
1339      dats[4].delaySelf();
1340      dats[5].delaySelf();
1341      for (int z=0;z<NUMDATS;++z)
1342      {
1343        Data& a=dats[z];
1344        Data r1=(((a+a)/two)+a-a)*one;  // scalar/*, matrix+-
1345        Data r2=(((a*a)/a+one)-one);    // scalar+-, matrix*/
1346        Data r3=(a.powD(two)/a.powD(one)); // scalar power
1347        Data r4=a.powD(a);      // matrix power
1348        if (z>LAZY)
1349        {
1350          assert(r1.isLazy() && r2.isLazy() && r3.isLazy() && r4.isLazy());
1351        }
1352        for (int i=0;i<DataTypes::noValues(shape);++i)
1353        {
1354          assert(std::abs(r1.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1355          assert(std::abs(r2.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1356          assert(std::abs(r3.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1357          assert(std::abs(r4.getDataAtOffset(i)-pow(data[i],i)) <=REL_TOL*pow(data[i],i));
1358        }
1359      }
1360    }
1361    
1362    
1363  void DataTestCase::testMemAlloc() {  void DataTestCase::testMemAlloc() {
1364    
1365    //    //

Legend:
Removed from v.1937  
changed lines
  Added in v.1938

  ViewVC Help
Powered by ViewVC 1.1.26