zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into cvm

Browse Source
This commit is contained in:
graham
2010-10-06 15:40:52 +01:00
parent 8cdc086186 6b3d5122d7
commit ebe711cae1
162 changed files with 5017 additions and 20767 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
applications/test/IndirectList/IndirectListTest.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2010-2010 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,6 +30,15 @@ Description
using namespace Foam;
template<class ListType>
void printInfo(const ListType& lst)
{
Info<< "addr: " << lst.addressing() << nl
<< "list: " << lst << nl
<< endl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
@ -42,8 +51,7 @@ int main(int argc, char *argv[])
completeList[i] = 0.1*i;
}
Info<< "raw : " << completeList << nl
<< endl;
Info<< "raw : " << completeList << nl << endl;
List<label> addresses(5);
@ -53,11 +61,9 @@ int main(int argc, char *argv[])
addresses[3] = 8;
addresses[4] = 5;
IndirectList<double> idl(completeList, addresses);
IndirectList<double> idl1(completeList, addresses);
Info<< "addr: " << idl.addressing() << nl
<< "list: " << idl() << nl
<< endl;
printInfo(idl1);
addresses[4] = 1;
addresses[3] = 0;
@ -65,11 +71,26 @@ int main(int argc, char *argv[])
addresses[1] = 8;
addresses[0] = 5;
idl.resetAddressing(addresses.xfer());
idl1.resetAddressing(addresses.xfer());
Info<< "addr: " << idl.addressing() << nl
<< "list: " << idl() << nl
<< endl;
printInfo(idl1);
// test copying
UIndirectList<double> uidl1(idl1);
IndirectList<double> idl2(uidl1);
IndirectList<double> idl3(idl2);
printInfo(uidl1);
idl1.resetAddressing(List<label>());
// idl2.resetAddressing(List<label>());
Info<<"after resetAddressing:" << nl << endl;
printInfo(uidl1);
printInfo(idl1);
printInfo(idl2);
printInfo(idl3);
Info<< "End\n" << endl;

2
applications/test/PackedList/PackedListTest.C
View File

@ -166,7 +166,7 @@ int main(int argc, char *argv[])
if (args.optionFound("info"))
{
packLst.print(Info);
packLst.printInfo(Info);
}
Info<< nl;

131
applications/test/PackedList1/PackedListTest1.C
View File

@ -42,42 +42,42 @@ int main(int argc, char *argv[])
Info<< "\ntest allocation with value\n";
PackedList<3> list1(5,1);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign uniform value\n";
list1 = 3;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign uniform value (with overflow)\n";
list1 = -1;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest zero\n";
list1 = 0;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest set() with default argument (max_value)\n";
list1.set(1);
list1.set(3);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest unset() with in-range and out-of-range\n";
list1.unset(3);
list1.unset(100000);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign between references\n";
list1[2] = 3;
list1[4] = list1[2];
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign between references, with chaining\n";
list1[0] = list1[4] = 1;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign between references, with chaining and auto-vivify\n";
list1[1] = list1[8] = list1[10] = list1[14] = 2;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest operator== between references\n";
@ -126,7 +126,7 @@ int main(int argc, char *argv[])
{
const PackedList<3>& constLst = list1;
Info<< "\ntest operator[] const with out-of-range index\n";
constLst.print(Info);
constLst.printInfo(Info, true);
if (constLst[20])
{
Info<< "[20] is true (unexpected)\n";
@ -136,7 +136,7 @@ int main(int argc, char *argv[])
Info<< "[20] is false (expected) list size should be unchanged "
<< "(const)\n";
}
constLst.print(Info);
constLst.printInfo(Info, true);
Info<< "\ntest operator[] non-const with out-of-range index\n";
if (list1[20])
@ -148,7 +148,7 @@ int main(int argc, char *argv[])
Info<< "[20] is false (expected) but list was resized?? "
<< "(non-const)\n";
}
list1.print(Info);
list1.printInfo(Info, true);
}
@ -157,85 +157,85 @@ int main(int argc, char *argv[])
{
Info<< "[20] is false, as expected\n";
}
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest resize with value (without reallocation)\n";
list1.resize(8, list1.max_value());
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest flip() function\n";
list1.flip();
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\nre-flip()\n";
list1.flip();
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest set() function\n";
list1.set(1, 5);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign bool\n";
list1 = false;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest assign bool\n";
list1 = true;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest resize without value (with reallocation)\n";
list1.resize(12);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest resize with value (with reallocation)\n";
list1.resize(25, list1.max_value());
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest resize smaller (should not touch allocation)\n";
list1.resize(8);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest append() operation\n";
list1.append(2);
list1.append(3);
list1.append(4);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest reserve() operation\n";
list1.reserve(32);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest shrink() operation\n";
list1.shrink();
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest setCapacity() operation\n";
list1.setCapacity(15);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest setCapacity() operation\n";
list1.setCapacity(100);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest operator[] assignment\n";
list1[16] = 5;
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest operator[] assignment with auto-vivify\n";
list1[36] = list1.max_value();
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest setCapacity smaller\n";
list1.setCapacity(24);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest resize much smaller\n";
list1.resize(150);
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest trim\n";
list1.trim();
list1.print(Info);
list1.printInfo(Info, true);
// add in some misc values
list1[31] = 1;
@ -245,40 +245,40 @@ int main(int argc, char *argv[])
Info<< "\ntest iterator\n";
PackedList<3>::iterator iter = list1.begin();
Info<< "begin():";
iter.print(Info) << "\n";
iter.printInfo(Info) << "\n";
Info<< "iterator:" << iter() << "\n";
iter() = 5;
iter.print(Info);
list1.print(Info);
iter.printInfo(Info);
list1.printInfo(Info, true);
iter = list1[31];
Info<< "iterator:" << iter() << "\n";
iter.print(Info);
iter.printInfo(Info);
Info<< "\ntest get() method\n";
Info<< "get(10):" << list1.get(10) << " and list[10]:" << list1[10] << "\n";
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest iterator indexing\n";
Info<< "cend() ";
list1.cend().print(Info) << "\n";
list1.cend().printInfo(Info) << "\n";
{
Info<< "\ntest assignment of iterator\n";
list1.print(Info);
list1.printInfo(Info, true);
Info<< "cend()\n";
list1.end().print(Info);
list1.end().printInfo(Info);
PackedList<3>::iterator cit = list1[100];
Info<< "out-of-range: ";
cit.print(Info);
cit.printInfo(Info);
cit = list1[15];
Info<< "in-range: ";
cit.print(Info);
cit.printInfo(Info);
Info<< "out-of-range: ";
cit = list1[1000];
cit.print(Info);
cit.printInfo(Info);
}
@ -289,7 +289,7 @@ int main(int argc, char *argv[])
++cit
)
{
cit.print(Info);
cit.printInfo(Info);
}
Info<< "\ntest operator[] auto-vivify\n";
@ -304,16 +304,16 @@ int main(int argc, char *argv[])
Info<< "size after write:" << list1.size() << "\n";
Info<< "list[45]:" << list1[45] << "\n";
list1[49] = list1[100];
list1.print(Info);
list1.printInfo(Info, true);
Info<< "\ntest copy constructor + append\n";
PackedList<3> list2(list1);
list2.append(4);
Info<< "source list:\n";
list1.print(Info);
list1.printInfo(Info, true);
Info<< "destination list:\n";
list2.print(Info);
list2.printInfo(Info, true);
Info<< "\ntest pattern that fills all bits\n";
PackedList<4> list3(8, 8);
@ -323,29 +323,50 @@ int main(int argc, char *argv[])
list3[pos--] = list3.max_value();
list3[pos--] = 0;
list3[pos--] = list3.max_value();
list3.print(Info);
list3.printInfo(Info, true);
Info<< "removed final value: " << list3.remove() << endl;
list3.print(Info);
list3.printInfo(Info, true);
Info<<"list: " << list3 << endl;
List<bool> list4(4, true);
List<bool> list4(16, false);
{
const List<bool>& constLst = list4;
// fill with some values
forAll(list4, i)
{
list4[i] = i % 3;
}
const UList<bool>& constLst = list4;
Info<< "\ntest operator[] const with out-of-range index\n";
Info<< constLst << endl;
if (constLst[20])
if (constLst[100])
{
Info<< "[20] is true (unexpected)\n";
Info<< "[100] is true (unexpected)\n";
}
else
{
Info<< "[20] is false (expected) list size should be unchanged "
<< "(const)\n";
Info<< "[100] is false (expected) "
<< "list size should be unchanged (const)\n";
}
Info<< constLst << endl;
}
PackedBoolList listb(list4);
Info<< "copied from bool list " << endl;
listb.printInfo(Info, true);
{
labelList indices = listb.used();
Info<< "indices: " << indices << endl;
}
Info<< "\n\nDone.\n";
return 0;

3
applications/test/PackedList3/PackedListTest3.C
View File

@ -33,7 +33,6 @@ Description
#include "StaticHashTable.H"
#include "cpuTime.H"
#include <vector>
#include "PackedList.H"
#include "PackedBoolList.H"
using namespace Foam;
@ -57,7 +56,7 @@ int main(int argc, char *argv[])
{
if ((i % nReport) == 0 && i)
{
Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s"
Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s"
<<endl;
}
packed[i] = 1;

3
applications/test/PackedList4/Make/files Normal file
View File

@ -0,0 +1,3 @@
PackedListTest4.C
EXE = $(FOAM_USER_APPBIN)/PackedListTest4

0
applications/test/PackedList4/Make/options Normal file
View File

207
applications/test/PackedList4/PackedListTest4.C Normal file
View File

@ -0,0 +1,207 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-2010 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Application
Description
\*---------------------------------------------------------------------------*/
#include "uLabel.H"
#include "IOstreams.H"
#include "PackedBoolList.H"
#include "IStringStream.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
PackedBoolList list1(20);
// set every third one on
forAll(list1, i)
{
list1[i] = !(i % 3);
}
Info<< "\nalternating bit pattern\n";
list1.printInfo(Info, true);
PackedBoolList list2 = ~list1;
Info<< "\ncomplementary bit pattern\n";
list2.printBits(Info);
// set every other on
forAll(list2, i)
{
list2[i] = !(i % 2);
}
Info<< "\nalternating bit pattern\n";
list2.printBits(Info);
list2.resize(28, false);
list2.resize(34, true);
list2.resize(40, false);
for (label i=0; i < 4; ++i)
{
list2[i] = true;
}
Info<< "\nresized with false, 6 true + 6 false, bottom 4 bits true\n";
list2.printInfo(Info, true);
labelList list2Labels = list2.used();
Info<< "\noperator|\n";
list1.printBits(Info);
list2.printBits(Info);
Info<< "==\n";
(list1 | list2).printBits(Info);
Info<< "\noperator& : does trim\n";
(list1 & list2).printBits(Info);
Info<< "\noperator^\n";
(list1 ^ list2).printBits(Info);
Info<< "\noperator|=\n";
{
PackedBoolList list3 = list1;
(list3 |= list2).printBits(Info);
}
Info<< "\noperator|= with UList<label>\n";
{
PackedBoolList list3 = list1;
(list3 |= list2Labels).printBits(Info);
}
Info<< "\noperator&=\n";
{
PackedBoolList list3 = list1;
(list3 &= list2).printBits(Info);
}
Info<< "\noperator+=\n";
{
PackedBoolList list3 = list1;
(list3 += list2).printBits(Info);
}
Info<< "\noperator+= with UList<label>\n";
{
PackedBoolList list3 = list1;
(list3 += list2Labels).printBits(Info);
}
Info<< "\noperator-=\n";
{
PackedBoolList list3 = list1;
(list3 -= list2).printBits(Info);
}
Info<< "\noperator-= with UList<label>\n";
{
PackedBoolList list3 = list1;
(list3 -= list2Labels).printBits(Info);
}
PackedBoolList list4
(
IStringStream
(
"(1 n 1 n 1 n 1 1 off 0 0 f f 0 y yes y true y false on t)"
)()
);
Info<< "\ntest Istream constructor\n";
list4.printInfo(Info, true);
Info<< list4 << " indices: " << list4.used()() <<endl;
Info<< "\nassign from labelList\n";
list4 = labelList
(
IStringStream
(
"(0 1 2 3 12 13 14 19 20 21)"
)()
);
list4.printInfo(Info, true);
Info<< list4 << " indices: " << list4.used()() <<endl;
Info<< "\nassign from indices\n";
list4.read
(
IStringStream
(
"{0 1 2 3 12 13 14 19 20 21}"
)()
);
list4.printInfo(Info, true);
Info<< list4 << " indices: " << list4.used()() <<endl;
List<bool> boolLst(list4.size());
forAll(list4, i)
{
boolLst[i] = list4[i];
}
Info<< "List<bool>: " << boolLst <<endl;
// check roundabout assignments
PackedList<2> pl2
(
IStringStream
(
"{(0 3)(1 3)(2 3)(3 3)(12 3)(13 3)(14 3)(19 3)(20 3)(21 3)}"
)()
);
Info<< "roundabout assignment: " << pl2 << endl;
list4.clear();
forAll(pl2, i)
{
list4[i] = pl2[i];
}
list4.write(Info, true) << endl;
list4.writeEntry("PackedBoolList", Info);
return 0;
}
// ************************************************************************* //