void TestTextFrameSorting::testSimpleSorting2() // cascading usecase
{
KWTextFrameSet tfs(0);
KWFrame *frame4 = createFrame(QPointF(120, 300), tfs); // note that each frame is 50 x 50 per default.
KWFrame *frame2 = createFrame(QPointF(120, 120), tfs);
KWFrame *frame3 = createFrame(QPointF(10, 240), tfs);
KWFrame *frame1 = createFrame(QPointF(10, 10), tfs);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame1);
QCOMPARE(tfs.m_frames[1], frame2);
QCOMPARE(tfs.m_frames[2], frame3);
QCOMPARE(tfs.m_frames[3], frame4);
KWPageManager pm;
tfs.setPageManager(&pm);
pm.appendPage();
pm.appendPage();
KWFrame *frame21 = createFrame(QPointF(120, 1000), tfs);
KWFrame *frame20 = createFrame(QPointF(10, 1000), tfs);
KWFrame *frame23 = createFrame(QPointF(120, 1200), tfs);
KWFrame *frame22 = createFrame(QPointF(10, 1110), tfs);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame1);
QCOMPARE(tfs.m_frames[1], frame2);
QCOMPARE(tfs.m_frames[2], frame3);
QCOMPARE(tfs.m_frames[3], frame4);
QCOMPARE(tfs.m_frames[4], frame20);
QCOMPARE(tfs.m_frames[5], frame21);
QCOMPARE(tfs.m_frames[6], frame22);
QCOMPARE(tfs.m_frames[7], frame23);
}
extern "C" __declspec(dllexport) int _cdecl init()
{
hdd.open(HDD_FILENAME, std::ios::in | std::ios::out | std::ios::binary);
if (!hdd.is_open())
{
std::fstream tfs(HDD_FILENAME, std::ios::out | std::ios::binary);
if (!tfs.is_open())
return -1;
hdInfo.verHI = VER_HI;
hdInfo.verLO = VER_LO;
hdInfo.size = 0;
tfs.seekg(0, std::fstream::beg);
tfs.write((char *)(&hdInfo), sizeof(hdInfo));
tfs.close();
hdd.open(HDD_FILENAME, std::ios::in | std::ios::out | std::ios::binary);
if (!hdd.is_open())
return -1;
}
hdd.seekg(0, std::fstream::beg);
hdd.read((char *)(&hdInfo), sizeof(hdInfo));
if (hdInfo.verHI > VER_HI)
return -2;
else if (hdInfo.verHI == VER_HI && hdInfo.verLO > VER_LO)
return -2;
return 0;
}
void TestTextFrameManagement::testFrameRemoval()
{
KWTextFrameSet tfs(0);
createFrame(QPointF(10, 10), tfs);
createFrame(QPointF(10, 120), tfs);
createFrame(QPointF(10, 1000), tfs);
QCOMPARE(tfs.frameCount(), 3);
tfs.framesEmpty(0);
QCOMPARE(tfs.frameCount(), 3);
tfs.framesEmpty(1);
QCOMPARE(tfs.frameCount(), 3); // don't autodelete when we don't have a pagemanager
KWPageManager pm;
pm.appendPage();
pm.appendPage();
tfs.setPageManager(&pm);
QCOMPARE(tfs.frameCount(), 3);
tfs.framesEmpty(0);
QCOMPARE(tfs.frameCount(), 3);
tfs.framesEmpty(1);
QCOMPARE(tfs.frameCount(), 2);
tfs.framesEmpty(1);
QCOMPARE(tfs.frameCount(), 2); // both on one page
tfs.framesEmpty(2);
QCOMPARE(tfs.frameCount(), 2); // leave one
}
void TestTextFrameSorting::testSimpleSorting()
{
KWTextFrameSet tfs(0);
KWFrame *frame1 = createFrame(QPointF(10, 10), tfs);
KWFrame *frame2 = createFrame(QPointF(120, 10), tfs);
frame2->shape()->setSize(QSizeF(100, 100));
KWFrame *frame3 = createFrame(QPointF(10, 110), tfs);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame1);
QCOMPARE(tfs.m_frames[1], frame3);
QCOMPARE(tfs.m_frames[2], frame2);
KWPageManager pm;
tfs.setPageManager(&pm);
pm.appendPage();
pm.appendPage();
KWFrame *frame4 = createFrame(QPointF(10, 1000), tfs); // page 2
KWFrame *frame5 = createFrame(QPointF(120, 1000), tfs);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame1);
QCOMPARE(tfs.m_frames[1], frame3);
QCOMPARE(tfs.m_frames[2], frame2);
QCOMPARE(tfs.m_frames[3], frame4);
QCOMPARE(tfs.m_frames[4], frame5);
}
/**
Extract a tar or tar.gz archive in \arg tarfile, to the path in \a destpath.
If \a verbose is true, echo a line on stdout for each file extracted.
The libtar and libz implementations are used. The file \a tarfile is tested
for the magic number indicating a gzip file, and if present gz stream i/o is
used, otherwise the file is assumed to be a normal .tar archive. Note that
the file extension is ignored since many files such as package format files,
use other extensions. The return result is true if the operation succeeded.
*/
bool targz_extract_all( const QString &tarfile, const QString &destpath, bool verbose )
{
QByteArray pathnameArr = tarfile.toLocal8Bit();
char *pathname = pathnameArr.data();
QByteArray prefixArr = destpath.toLocal8Bit();
char *prefix = destpath.isEmpty() ? 0 : prefixArr.data();
TAR *tarHandle;
int options = TAR_GNU;
if ( verbose ) options |= TAR_VERBOSE;
int filemode = 0; // only care about this if creating files (ie untar)
tartype_t *arctype = 0;
{
// QFile and stream go away at end of scope
QFile tfs( tarfile );
if ( !tfs.exists() )
{
qWarning( "Targz_extract_all: file %s doesnt exist", pathname );
return false;
}
tfs.open(QIODevice::ReadOnly);
QDataStream tarbytes( &tfs );
quint8 b1, b2;
// if the first two bytes are the magic numbers for a gzip format
// file, use the above zlib wrapped i/o function pointers, otherwise
// assume normal uncompressed tar format (default)
tarbytes >> b1 >> b2;
if ( b1 == 0x1f && b2 == 0x8b ) arctype = &zlibtype;
}
int result = tar_open( &tarHandle, pathname, arctype, O_RDONLY, filemode, options);
if ( result < 0 )
{
qWarning( "error opening tar file %s: %s", pathname, strerror(errno) );
return false;
}
result = tar_extract_all( tarHandle, prefix );
if ( result < 0 )
qWarning( "error extracting tar file %s: %s", pathname, strerror(errno) );
tar_close( tarHandle );
return ( result >= 0 );
}
void TestTextFrameSorting::testCopyAfterTextSorting()
{
KWTextFrameSet tfs(0);
KWTextFrame * frame1 = createFrame(QPointF(70, 1300), tfs);
KWFrame * frame2 = createCopyFrame(QPointF(70, 100), frame1->shape(), tfs);
KWTextFrame * frame3 = createFrame(QPointF(70, 2000), tfs);
tfs.removeFrame(frame1);
QCOMPARE(tfs.m_frames[0], frame2);
QCOMPARE(tfs.m_frames[1], frame3);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame3);
QCOMPARE(tfs.m_frames[1], frame2);
}
void TestTextFrameSorting::testSortingById()
{
KWTextFrameSet tfs(0);
KWTextFrame * frame1 = createFrame(QPointF(10, 200), tfs);
KWTextFrame * frame2 = createFrame(QPointF(120, 10), tfs);
KWTextFrame * frame3 = createFrame(QPointF(10, 10), tfs);
frame1->setSortingId(1);
frame2->setSortingId(2);
frame3->setSortingId(3);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame1);
QCOMPARE(tfs.m_frames[1], frame2);
QCOMPARE(tfs.m_frames[2], frame3);
}
void TestTextFrameSorting::testSortingOnPagespread()
{
KWTextFrameSet tfs(0);
KWFrame * frame1 = createFrame(QPointF(10, 200), tfs);
KWFrame * frame2 = createFrame(QPointF(120, 10), tfs);
KWFrame * frame3 = createFrame(QPointF(10, 10), tfs);
KWFrame * frame4 = createFrame(QPointF(340, 10), tfs);
KWFrame * frame5 = createFrame(QPointF(230, 10), tfs);
KWPageManager pm;
KWPage page = pm.appendPage();
page.setPageNumber(2);
KOdfPageLayoutData layout = page.pageStyle().pageLayout();
layout.width = 450;
layout.height = 150;
page.setDirectionHint(KOdfText::LeftRightTopBottom);
page.setPageSide(KWPage::PageSpread);
page.pageStyle().setPageLayout(layout);
page = pm.appendPage();
page.setDirectionHint(KOdfText::LeftRightTopBottom);
layout.width = 200;
page.pageStyle().setPageLayout(layout);
tfs.setPageManager(&pm);
QCOMPARE(page.offsetInDocument(), 150.);
// test KWPageManager::pageNumber first
QCOMPARE(pm.begin().pageNumber(), 2);
QCOMPARE(pm.pageNumber(frame2->shape()), 2);
QCOMPARE(pm.pageNumber(frame1->shape()), 4);
QCOMPARE(KWTextFrameSet::sortTextFrames(frame4, frame5), false);
QCOMPARE(KWTextFrameSet::sortTextFrames(frame5, frame4), true);
QCOMPARE(KWTextFrameSet::sortTextFrames(frame2, frame4), true);
QCOMPARE(KWTextFrameSet::sortTextFrames(frame1, frame4), false);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
QCOMPARE(tfs.m_frames[0], frame3);
QCOMPARE(tfs.m_frames[1], frame2);
QCOMPARE(tfs.m_frames[2], frame5);
QCOMPARE(tfs.m_frames[3], frame4);
QCOMPARE(tfs.m_frames[4], frame1);
}
void test_convolver() {
// csl::CGestalt::set_block_size(2048);
Convolver cv("../../Data/Quadraverb_large_L.aiff");
ThreadedReader tfs(cv);
SoundFile fi("../../Data/rim3_L.aiff");
fi.open_for_read();
logMsg("playing sound file...");
fi.trigger();
run_test(fi);
logMsg("sound file player done.");
cv.set_input(fi);
fi.trigger();
logMsg("playing convolver...");
// tfs.set_threshold(2048);
// tfs.start();
run_test(cv);
// tfs.stop();
fi.close();
logMsg("convolver done.");
}
void TestTextFrameSorting::testRtlSorting()
{
KWTextFrameSet tfs(0);
KWFrame * frame1 = createFrame(QPointF(10, 10), tfs);
KWFrame * frame2 = createFrame(QPointF(120, 10), tfs);
KWPageManager pm;
KWPage page = pm.appendPage();
page.setDirectionHint(KOdfText::RightLeftTopBottom);
QCOMPARE(page.directionHint(), KOdfText::RightLeftTopBottom);
KOdfPageLayoutData layout = page.pageStyle().pageLayout();
layout.width = 200;
page.pageStyle().setPageLayout(layout);
tfs.setPageManager(&pm);
qSort(tfs.m_frames.begin(), tfs.m_frames.end(), KWTextFrameSet::sortTextFrames);
// in RTL columns also sort right-to-left
QCOMPARE(tfs.m_frames[0], frame2);
QCOMPARE(tfs.m_frames[1], frame1);
}
void
parse(const std::string& xmlData, SAXDocumentHandler& docHandler, SAXErrorHandler& errHandler)
{
std::istringstream tfs(xmlData);
parse(tfs, docHandler, errHandler);
}
void TemplateFileServer::Serve(HTTPProvider *server, const Anope::string &page_name, HTTPClient *client, HTTPMessage &message, HTTPReply &reply, Replacements &r)
{
int fd = open((template_base + "/" + this->file_name).c_str(), O_RDONLY);
if (fd < 0)
{
Log(LOG_NORMAL, "httpd") << "Error serving file " << page_name << " (" << (template_base + "/" + this->file_name) << "): " << strerror(errno);
client->SendError(HTTP_PAGE_NOT_FOUND, "Page not found");
return;
}
Anope::string buf;
int i;
char buffer[BUFSIZE];
while ((i = read(fd, buffer, sizeof(buffer) - 1)) > 0)
{
buffer[i] = 0;
buf += buffer;
}
close(fd);
Anope::string finished;
bool escaped = false;
for (unsigned j = 0; j < buf.length(); ++j)
{
if (buf[j] == '\\' && j + 1 < buf.length() && (buf[j + 1] == '{' || buf[j + 1] == '}'))
escaped = true;
else if (buf[j] == '{' && !escaped)
{
size_t f = buf.substr(j).find('}');
if (f == Anope::string::npos)
break;
const Anope::string &content = buf.substr(j + 1, f - 1);
if (content.find("IF ") == 0)
{
std::vector<Anope::string> tokens;
spacesepstream(content).GetTokens(tokens);
if (tokens.size() == 4 && tokens[1] == "EQ")
{
Anope::string first = FindReplacement(r, tokens[2]), second = FindReplacement(r, tokens[3]);
if (first.empty())
first = tokens[2];
if (second.empty())
second = tokens[3];
bool stackok = IfStack.empty() || IfStack.top();
IfStack.push(stackok && first == second);
}
else if (tokens.size() == 3 && tokens[1] == "EXISTS")
{
bool stackok = IfStack.empty() || IfStack.top();
IfStack.push(stackok && r.count(tokens[2]) > 0);
}
else
Log() << "Invalid IF in web template " << this->file_name;
}
else if (content == "ELSE")
{
if (IfStack.empty())
Log() << "Invalid ELSE with no stack in web template" << this->file_name;
else
{
bool old = IfStack.top();
IfStack.pop(); // Pop off previous if()
bool stackok = IfStack.empty() || IfStack.top();
IfStack.push(stackok && !old); // Push back the opposite of what was popped
}
}
else if (content == "END IF")
{
if (IfStack.empty())
Log() << "END IF with empty stack?";
else
IfStack.pop();
}
else if (content.find("FOR ") == 0)
{
std::vector<Anope::string> tokens;
spacesepstream(content).GetTokens(tokens);
if (tokens.size() != 4 || tokens[2] != "IN")
Log() << "Invalid FOR in web template " << this->file_name;
else
{
std::vector<Anope::string> temp_variables, real_variables;
commasepstream(tokens[1]).GetTokens(temp_variables);
commasepstream(tokens[3]).GetTokens(real_variables);
if (temp_variables.size() != real_variables.size())
Log() << "Invalid FOR in web template " << this->file_name << " variable mismatch";
else
ForLoop::Stack.push_back(ForLoop(j + f, r, temp_variables, real_variables));
}
}
else if (content == "END FOR")
{
if (ForLoop::Stack.empty())
Log() << "END FOR with empty stack?";
else
{
ForLoop &fl = ForLoop::Stack.back();
if (fl.finished(r))
ForLoop::Stack.pop_back();
else
{
fl.increment(r);
if (fl.finished(r))
ForLoop::Stack.pop_back();
else
{
j = fl.start; // Move pointer back to start of the loop
continue; // To prevent skipping over this block which doesn't exist anymore
}
}
}
}
else if (content.find("INCLUDE ") == 0)
{
std::vector<Anope::string> tokens;
spacesepstream(content).GetTokens(tokens);
if (tokens.size() != 2)
Log() << "Invalid INCLUDE in web template " << this->file_name;
else
{
if (!finished.empty())
{
reply.Write(finished); // Write out what we have currently so we insert this files contents here
finished.clear();
}
TemplateFileServer tfs(tokens[1]);
tfs.Serve(server, page_name, client, message, reply, r);
}
}
else
{
// If the if stack is empty or we are in a true statement
bool ifok = IfStack.empty() || IfStack.top();
bool forok = ForLoop::Stack.empty() || !ForLoop::Stack.back().finished(r);
if (ifok && forok)
{
const Anope::string &replacement = FindReplacement(r, content.substr(0, f - 1));
finished += replacement;
}
}
j += f; // Skip over this whole block
}
else
{
escaped = false;
// If the if stack is empty or we are in a true statement
bool ifok = IfStack.empty() || IfStack.top();
bool forok = ForLoop::Stack.empty() || !ForLoop::Stack.back().finished(r);
if (ifok && forok)
finished += buf[j];
}
}
if (!finished.empty())
reply.Write(finished);
}
void testSymmetrize(Pooma::Tester &tester)
{
tester.out() << std::endl << "========= " << D << "D =========" << std::endl;
// Create Full, Antisymmetric, Symmetric, and Diagonal Tensors as inputs:
Tensor<D,double,Full> tf;
double value = 1.0;
for (int i = 0; i < D; i++) {
for (int j = 0; j < D; j++) {
tf(i,j) = value;
value++;
}
}
tester.out() << "tf: " << tf << std::endl;
Tensor<D,double,Antisymmetric> ta;
value = 1.0;
for (int i = 0; i < TensorStorageSize<D,Antisymmetric>::Size; i++) {
ta(i) = i + 1.0;
}
tester.out() << "ta: " << ta << std::endl;
Tensor<D,double,Symmetric> ts;
for (int i = 0; i < TensorStorageSize<D,Symmetric>::Size; i++) {
ts(i) = i + 1.0;
}
tester.out() << "ts: " << ts << std::endl;
Tensor<D,double,Diagonal> td;
for (int i = 0; i < TensorStorageSize<D,Diagonal>::Size; i++) {
td(i) = i + 1.0;
}
tester.out() << "td: " << td << std::endl;
//---------------------------------------------------------------------------
// Make Fields of these types, to test forwarding of symmetrize<>() function:
// Create the physical Domains:
const int nVerts = 6;
const int nCells = nVerts - 1;
int nCellsTot = 1;
Interval<D> vertexDomain;
for (int d = 0; d < D; d++) {
vertexDomain[d] = Interval<1>(nVerts);
nCellsTot *= nCells;
}
// Create the (uniform, logically rectilinear) mesh.
Vector<D> origin(0.0), spacings(0.2);
typedef UniformRectilinearMesh<D> Mesh_t;
DomainLayout<D> layout(vertexDomain, GuardLayers<D>(0));
// Create the Fields:
Centering<D> cell = canonicalCentering<D>(CellType, Continuous);
// Full, Antisymmetric, Symmetric, Diagonal Tensor Fields:
Field<Mesh_t,Tensor<D,double,Full> > tff(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<D,double,Symmetric> >
tfs(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<D,double,Antisymmetric> >
tfa(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<D,double,Diagonal> > tfd(cell, layout, origin, spacings);
// Assign to the single-Tensor values:
tff = tf;
tfs = ts;
tfa = ta;
tfd = td;
#ifndef __MWERKS__ // This whole module is too much for CW5 to compile
// --------------------------------------------------------------------------
// Symmetrize from Full tensor to {Antisymmetric, Symmetric, Diagonal}:
// To Antisymmetric:
if (!tester.check("symmetrize<Antisymmetric>(tf): ",
(symmetrize<Antisymmetric>(tf) ==
makeAntisymmetric(tf)))) {
tester.out() << "symmetrize<Antisymmetric>(tf) = "
<< symmetrize<Antisymmetric>(tf)
<< " != makeAntisymmetric(tf) = "
<< makeAntisymmetric(tf) << std::endl;
}
if (!tester.check("sum(symmetrize<Antisymmetric>(tff)): ",
(sum(symmetrize<Antisymmetric>(tff)) ==
nCellsTot*makeAntisymmetric(tf)))) {
tester.out() << "sum(symmetrize<Antisymmetric>(tff)) = "
<< sum(symmetrize<Antisymmetric>(tff))
<< " != nCellsTot*makeAntisymmetric(tf) = "
<< nCellsTot*makeAntisymmetric(tf) << std::endl;
}
// To Symmetric:
if (!tester.check("symmetrize<Symmetric>(tf): ",
(symmetrize<Symmetric>(tf) ==
makeSymmetric(tf)))) {
tester.out() << "symmetrize<Symmetric>(tf) = "
<< symmetrize<Symmetric>(tf)
<< " != makeSymmetric(tf) = "
<< makeSymmetric(tf) << std::endl;
}
if (!tester.check("sum(symmetrize<Symmetric>(tff)): ",
(sum(symmetrize<Symmetric>(tff)) ==
nCellsTot*makeSymmetric(tf)))) {
tester.out() << "sum(symmetrize<Symmetric>(tff)) = "
<< sum(symmetrize<Symmetric>(tff))
<< " != nCellsTot*makeSymmetric(tf) = "
<< nCellsTot*makeSymmetric(tf) << std::endl;
}
// To Diagonal::
if (!tester.check("symmetrize<Diagonal>(tf): ",
(symmetrize<Diagonal>(tf) ==
makeDiagonal(tf)))) {
tester.out() << "symmetrize<Diagonal>(tf) = "
<< symmetrize<Diagonal>(tf)
<< " != makeDiagonal(tf) = "
<< makeDiagonal(tf) << std::endl;
}
if (!tester.check("sum(symmetrize<Diagonal>(tff)): ",
(sum(symmetrize<Diagonal>(tff)) ==
nCellsTot*makeDiagonal(tf)))) {
tester.out() << "sum(symmetrize<Diagonal>(tff)) = "
<< sum(symmetrize<Diagonal>(tff))
<< " != nCellsTot*makeDiagonal(tf) = "
<< nCellsTot*makeDiagonal(tf) << std::endl;
}
// --------------------------------------------------------------------------
// Symmetrize from Antisymmetric tensor to {Full, Symmetric, Diagonal}:
// To Full:
if (!tester.check("symmetrize<Full>(ta): ",
(symmetrize<Full>(ta) ==
makeFull(ta)))) {
tester.out() << "symmetrize<Full>(ta) = "
<< symmetrize<Full>(ta)
<< " != makeFull(ta) = "
<< makeFull(ta) << std::endl;
}
if (!tester.check("sum(symmetrize<Full>(tfa)): ",
(sum(symmetrize<Full>(tfa)) ==
nCellsTot*makeFull(ta)))) {
tester.out() << "sum(symmetrize<Full>(tfa)) = "
<< sum(symmetrize<Full>(tfa))
<< " != nCellsTot*makeFull(ta) = "
<< nCellsTot*makeFull(ta) << std::endl;
}
// To Symmetric:
if (!tester.check("symmetrize<Symmetric>(ta): ",
(symmetrize<Symmetric>(ta) ==
makeSymmetric(ta)))) {
tester.out() << "symmetrize<Symmetric>(ta) = "
<< symmetrize<Symmetric>(ta)
<< " != makeSymmetric(ta) = "
<< makeSymmetric(ta) << std::endl;
}
if (!tester.check("sum(symmetrize<Symmetric>(tfa)): ",
(sum(symmetrize<Symmetric>(tfa)) ==
nCellsTot*makeSymmetric(ta)))) {
tester.out() << "sum(symmetrize<Symmetric>(tfa)) = "
<< sum(symmetrize<Symmetric>(tfa))
<< " != nCellsTot*makeSymmetric(ta) = "
<< nCellsTot*makeSymmetric(ta) << std::endl;
}
// To Diagonal::
if (!tester.check("symmetrize<Diagonal>(ta): ",
(symmetrize<Diagonal>(ta) ==
makeDiagonal(ta)))) {
tester.out() << "symmetrize<Diagonal>(ta) = "
<< symmetrize<Diagonal>(ta)
<< " != makeDiagonal(ta) = "
<< makeDiagonal(ta) << std::endl;
}
if (!tester.check("sum(symmetrize<Diagonal>(tfa)): ",
(sum(symmetrize<Diagonal>(tfa)) ==
nCellsTot*makeDiagonal(ta)))) {
tester.out() << "sum(symmetrize<Diagonal>(tfa)) = "
<< sum(symmetrize<Diagonal>(tfa))
<< " != nCellsTot*makeDiagonal(ta) = "
<< nCellsTot*makeDiagonal(ta) << std::endl;
}
#endif // __MWERKS__
// --------------------------------------------------------------------------
// Symmetrize from Symmetric tensor to {Full, Antisymmetric, Diagonal}:
// To Full:
if (!tester.check("symmetrize<Full>(ts): ",
(symmetrize<Full>(ts) ==
makeFull(ts)))) {
tester.out() << "symmetrize<Full>(ts) = "
<< symmetrize<Full>(ts)
<< " != makeFull(ts) = "
<< makeFull(ts) << std::endl;
}
if (!tester.check("sum(symmetrize<Full>(tfs)): ",
(sum(symmetrize<Full>(tfs)) ==
nCellsTot*makeFull(ts)))) {
tester.out() << "sum(symmetrize<Full>(tfs)) = "
<< sum(symmetrize<Full>(tfs))
<< " != nCellsTot*makeFull(ts) = "
<< nCellsTot*makeFull(ts) << std::endl;
}
// To Antisymmetric:
if (!tester.check("symmetrize<Antisymmetric>(ts): ",
(symmetrize<Antisymmetric>(ts) ==
makeAntisymmetric(ts)))) {
tester.out() << "symmetrize<Antisymmetric>(ts) = "
<< symmetrize<Antisymmetric>(ts)
<< " != makeAntisymmetric(ts) = "
<< makeAntisymmetric(ts) << std::endl;
}
if (!tester.check("sum(symmetrize<Antisymmetric>(tfs)): ",
(sum(symmetrize<Antisymmetric>(tfs)) ==
nCellsTot*makeAntisymmetric(ts)))) {
tester.out() << "sum(symmetrize<Antisymmetric>(tfs)) = "
<< sum(symmetrize<Antisymmetric>(tfs))
<< " != nCellsTot*makeAntisymmetric(ts) = "
<< nCellsTot*makeAntisymmetric(ts) << std::endl;
}
// To Diagonal::
if (!tester.check("symmetrize<Diagonal>(ts): ",
(symmetrize<Diagonal>(ts) ==
makeDiagonal(ts)))) {
tester.out() << "symmetrize<Diagonal>(ts) = "
<< symmetrize<Diagonal>(ts)
<< " != makeDiagonal(ts) = "
<< makeDiagonal(ts) << std::endl;
}
if (!tester.check("sum(symmetrize<Diagonal>(tfs)): ",
(sum(symmetrize<Diagonal>(tfs)) ==
nCellsTot*makeDiagonal(ts)))) {
tester.out() << "sum(symmetrize<Diagonal>(tfs)) = "
<< sum(symmetrize<Diagonal>(tfs))
<< " != nCellsTot*makeDiagonal(ts) = "
<< nCellsTot*makeDiagonal(ts) << std::endl;
}
// --------------------------------------------------------------------------
// Symmetrize from Diagonal tensor to {Full, Antisymmetric, Symmetric}:
// To Full:
if (!tester.check("symmetrize<Full>(td): ",
(symmetrize<Full>(td) ==
makeFull(td)))) {
tester.out() << "symmetrize<Full>(td) = "
<< symmetrize<Full>(td)
<< " != makeFull(td) = "
<< makeFull(td) << std::endl;
}
if (!tester.check("sum(symmetrize<Full>(tfd)): ",
(sum(symmetrize<Full>(tfd)) ==
nCellsTot*makeFull(td)))) {
tester.out() << "sum(symmetrize<Full>(tfd)) = "
<< sum(symmetrize<Full>(tfd))
<< " != nCellsTot*makeFull(td) = "
<< nCellsTot*makeFull(td) << std::endl;
}
// To Antisymmetric:
if (!tester.check("symmetrize<Antisymmetric>(td): ",
(symmetrize<Antisymmetric>(td) ==
makeAntisymmetric(td)))) {
tester.out() << "symmetrize<Antisymmetric>(td) = "
<< symmetrize<Antisymmetric>(td)
<< " != makeAntisymmetric(td) = "
<< makeAntisymmetric(td) << std::endl;
}
if (!tester.check("sum(symmetrize<Antisymmetric>(tfd)): ",
(sum(symmetrize<Antisymmetric>(tfd)) ==
nCellsTot*makeAntisymmetric(td)))) {
tester.out() << "sum(symmetrize<Antisymmetric>(tfd)) = "
<< sum(symmetrize<Antisymmetric>(tfd))
<< " != nCellsTot*makeAntisymmetric(td) = "
<< nCellsTot*makeAntisymmetric(td) << std::endl;
}
// To Symmetric:
if (!tester.check("symmetrize<Symmetric>(td): ",
(symmetrize<Symmetric>(td) ==
makeSymmetric(td)))) {
tester.out() << "symmetrize<Symmetric>(td) = "
<< symmetrize<Symmetric>(td)
<< " != makeSymmetric(td) = "
<< makeSymmetric(td) << std::endl;
}
if (!tester.check("sum(symmetrize<Symmetric>(tfd)): ",
(sum(symmetrize<Symmetric>(tfd)) ==
nCellsTot*makeSymmetric(td)))) {
tester.out() << "sum(symmetrize<Symmetric>(tfd)) = "
<< sum(symmetrize<Symmetric>(tfd))
<< " != nCellsTot*makeSymmetric(td) = "
<< nCellsTot*makeSymmetric(td) << std::endl;
}
}
void testTrace(Pooma::Tester &tester)
{
// Create the physical Domains:
const int nVerts = 6;
const int nCells = nVerts - 1;
int nCellsTot = 1;
Interval<Dim> vertexDomain;
for (int d = 0; d < Dim; d++) {
vertexDomain[d] = Interval<1>(nVerts);
nCellsTot *= nCells;
}
// Create the (uniform, logically rectilinear) mesh.
Vector<Dim> origin(0.0), spacings(0.2);
typedef UniformRectilinearMesh<Dim> Mesh_t;
DomainLayout<Dim> layout(vertexDomain, GuardLayers<Dim>(0));
// Create the Fields:
Centering<Dim> cell = canonicalCentering<Dim>(CellType, Continuous);
// Full, Antisymmetric, Symmetric, Diagonal Tensor Fields:
Field<Mesh_t,Tensor<Dim,double,Full> > tff(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<Dim,double,Antisymmetric> >
tfa(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<Dim,double,Symmetric> >
tfs(cell, layout, origin, spacings);
Field<Mesh_t,Tensor<Dim,double,Diagonal> >
tfd(cell, layout, origin, spacings);
// Assign values:
Tensor<Dim,double,Full> tf(0.0);
Tensor<Dim,double,Antisymmetric> ta(0.0);
Tensor<Dim,double,Symmetric> ts(0.0);
Tensor<Dim,double,Diagonal> td(0.0);
double fullSymDiagTrace = 0.0;
for (int i = 0; i < Dim; i++) {
for (int j = 0; j < Dim; j++) {
tf(i,j) = (i+1)*(i+1) + (j+1)*(j+1) + (i+4)*(j+4) + i;
if (i == j) fullSymDiagTrace += tf(i,j);
}
}
// tester.out() << "tf = " << tf << std::endl;
ta = symmetrize<Antisymmetric>(tf);
ts = symmetrize<Symmetric>(tf);
td = symmetrize<Diagonal>(tf);
tff = tf;
tfa = ta;
tfs = ts;
tfd = td;
// Test trace of Full Tensor:
double traceValue;
traceValue = sum(trace(tff));
tester.out() << "traceValue = sum(trace(tff)): " << traceValue << std::endl;
tester.check("traceValue", traceValue, fullSymDiagTrace*nCellsTot);
// Test trace of Symmetric Tensor:
traceValue = sum(trace(tfs));
if (!tester.check("traceValue", traceValue, fullSymDiagTrace*nCellsTot)) {
tester.out() << Dim << "D, sum(trace(tfs)): " << traceValue
<< " != fullSymDiagTrace*nCellsTot = "
<< fullSymDiagTrace*nCellsTot << std::endl;
}
// Test trace of Antisymmetric Tensor:
traceValue = sum(trace(tfa));
if (!tester.check("traceValue", traceValue, 0.0*nCellsTot)) {
tester.out() << Dim << "D, sum(trace(tfa)): " << traceValue
<< " != 0.0" << std::endl;
}
// Test trace of Diagonal Tensor:
traceValue = sum(trace(tfd));
if (!tester.check("traceValue", traceValue, fullSymDiagTrace*nCellsTot)) {
tester.out() << Dim << "D, sum(trace(tfd)): " << traceValue
<< " != fullSymDiagTrace*nCellsTot = "
<< fullSymDiagTrace*nCellsTot << std::endl;
}
}
