int
main(int32_t argc, char *argv[])
{
nsresult rv;
ScopedXPCOM xpcom("STS Parser Tests");
if (xpcom.failed())
return -1;
// Initialize a profile folder to ensure a clean shutdown.
nsCOMPtr<nsIFile> profile = xpcom.GetProfileDirectory();
if (!profile) {
fail("Couldn't get the profile directory.");
return -1;
}
// grab handle to the service
nsCOMPtr<nsISiteSecurityService> sss;
sss = do_GetService("@mozilla.org/ssservice;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
int rv0, rv1;
nsTArray<bool> rvs(24);
// *** parsing tests
printf("*** Attempting to parse valid STS headers ...\n");
// SHOULD SUCCEED:
rvs.AppendElement(TestSuccess("max-age=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age =100", false, 100, false, sss));
rvs.AppendElement(TestSuccess(" max-age=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = \"100\" ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age=\"100\"", false, 100, false, sss));
rvs.AppendElement(TestSuccess(" max-age =\"100\" ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("\tmax-age\t=\t\"100\"\t", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("maX-aGe=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("MAX-age =100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-AGE=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("Max-Age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("MAX-AGE = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age=100;includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age=100\t; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess(" max-age=100; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("maX-aGe=100; includeSUBDOMAINS", false, 100, true, sss));
rvs.AppendElement(TestSuccess("MAX-age =100; includeSubDomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-AGE=100; iNcLuDeSuBdoMaInS", false, 100, true, sss));
rvs.AppendElement(TestSuccess("Max-Age = 100; includesubdomains ", false, 100, true, sss));
rvs.AppendElement(TestSuccess("INCLUDESUBDOMAINS;MaX-AgE = 100 ", false, 100, true, sss));
// Turns out, the actual directive is entirely optional (hence the
// trailing semicolon)
rvs.AppendElement(TestSuccess("max-age=100;includeSubdomains;", true, 100, true, sss));
// these are weird tests, but are testing that some extended syntax is
// still allowed (but it is ignored)
rvs.AppendElement(TestSuccess("max-age=100 ; includesubdomainsSomeStuff", true, 100, false, sss));
rvs.AppendElement(TestSuccess("\r\n\t\t \tcompletelyUnrelated = foobar; max-age= 34520103 \t \t; alsoUnrelated;asIsThis;\tincludeSubdomains\t\t \t", true, 34520103, true, sss));
rvs.AppendElement(TestSuccess("max-age=100; unrelated=\"quoted \\\"thingy\\\"\"", true, 100, false, sss));
rv0 = rvs.Contains(false) ? 1 : 0;
if (rv0 == 0)
passed("Successfully Parsed STS headers with mixed case and LWS");
rvs.Clear();
// SHOULD FAIL:
printf("*** Attempting to parse invalid STS headers (should not parse)...\n");
// invalid max-ages
rvs.AppendElement(TestFailure("max-age", sss));
rvs.AppendElement(TestFailure("max-age ", sss));
rvs.AppendElement(TestFailure("max-age=p", sss));
rvs.AppendElement(TestFailure("max-age=*1p2", sss));
rvs.AppendElement(TestFailure("max-age=.20032", sss));
rvs.AppendElement(TestFailure("max-age=!20032", sss));
rvs.AppendElement(TestFailure("max-age==20032", sss));
// invalid headers
rvs.AppendElement(TestFailure("foobar", sss));
rvs.AppendElement(TestFailure("maxage=100", sss));
rvs.AppendElement(TestFailure("maxa-ge=100", sss));
rvs.AppendElement(TestFailure("max-ag=100", sss));
rvs.AppendElement(TestFailure("includesubdomains", sss));
rvs.AppendElement(TestFailure(";", sss));
rvs.AppendElement(TestFailure("max-age=\"100", sss));
// The max-age directive here doesn't conform to the spec, so it MUST
// be ignored. Consequently, the REQUIRED max-age directive is not
// present in this header, and so it is invalid.
rvs.AppendElement(TestFailure("max-age=100, max-age=200; includeSubdomains", sss));
rvs.AppendElement(TestFailure("max-age=100 includesubdomains", sss));
rvs.AppendElement(TestFailure("max-age=100 bar foo", sss));
rvs.AppendElement(TestFailure("max-age=100randomstuffhere", sss));
// All directives MUST appear only once in an STS header field.
rvs.AppendElement(TestFailure("max-age=100; max-age=200", sss));
rvs.AppendElement(TestFailure("includeSubdomains; max-age=200; includeSubdomains", sss));
rvs.AppendElement(TestFailure("max-age=200; includeSubdomains; includeSubdomains", sss));
// The includeSubdomains directive is valueless.
rvs.AppendElement(TestFailure("max-age=100; includeSubdomains=unexpected", sss));
// LWS must have at least one space or horizontal tab
rvs.AppendElement(TestFailure("\r\nmax-age=200", sss));
rv1 = rvs.Contains(false) ? 1 : 0;
if (rv1 == 0)
passed("Avoided parsing invalid STS headers");
return (rv0 + rv1);
}
int main () {
FILE* iImage;
FILE* dImage;
FILE* snp;
FILE* edp;
unsigned int buffer;
iImage = fopen ("iimage.bin","rb");
dImage = fopen("dimage.bin","rb");
snp = fopen("snapshot.rpt","w");
edp = fopen("error_dump.rpt","w");
int i=0;
int j;
while(fread(&buffer, 4, 1, dImage)){
i++;
if(i == 1){
registers[sp] = rvs(buffer);
}
if(i == 2)Dnum = rvs(buffer);
if(i > 2)Dm[i-3] = rvs(buffer);
}
i = 0;
while(fread(&buffer, 4, 1, iImage)){
i++;
if(i > 256){
error_ao = 1;
break;
}
unsigned int db = rvs(buffer);
if(i == 1){
inPC = db;
PC = db;
}else if(i == 2){
Inum = db;
}else if(i > Inum+2){
break;
}else{
Im[i-3] = db;
}
}
int cycle = 0;
IF = Im[0];
fprintf(snp,"cycle %d\n",cycle);
for(j = 0;j < 32;j++)fprintf(snp,"$%02d: 0x%08X\n",j,registers[j]);
fprintf(snp,"PC: 0x%08X\n",PC);
fprintf(snp,"IF: 0x%08X\n",IF);
fprintf(snp,"ID: %s\n",ID);
fprintf(snp,"EX: %s\n",EX);
fprintf(snp,"DM: %s\n",DM);
fprintf(snp,"WB: %s\n\n\n",WB);
cycle++;
char fwdedad = 0;
int fwdedr = 0;
int preIF = 0;
for(i = 0;i < Inum;){
if(fwded == 1)fwded = 0;
if(for_id == 1){
fwdedad = forad;
fwdedr = fwdr;
fwded = 1;
}
if(error() != 0 || error_w0 == 1 || error_no == 1){
if(error_w0 == 1)fprintf(edp, "In cycle %d: Write $0 Error\n", cycle);
if(error_ao == 1){
fprintf(edp, "In cycle %d: Address Overflow\n", cycle);
end = 1;
}
if(error_dm == 1){
fprintf(edp, "In cycle %d: Misalignment Error\n", cycle);
end = 1;
}
if(error_no == 1)fprintf(edp, "In cycle %d: Number Overflow\n", cycle);
error_w0 = 0;
error_ao = 0;
error_no = 0;
error_dm = 0;
}
if(end)break;
if(IF == -1 && strcmp(EX,"HALT") == 0 && strcmp(ID,"HALT") == 0 && strcmp(DM,"HALT") == 0 && strcmp(WB,"HALT") == 0){
break;
}
fprintf(snp,"cycle %d\n",cycle);
for(j = 0;j < 32;j++){
fprintf(snp,"$%02d: 0x%08X\n",j,registers[j]);
}
if(stall == 0)PC = PC+4;
if(stall == 0)preIF = IF;
IF = Im[(PC-inPC)/4];
write();
dm();
excute();
if(flush == 1){
decode(0);
}else{
decode(preIF);
}
fprintf(snp,"PC: 0x%08X\n",PC);
if(flush == 1){
fprintf(snp,"IF: 0x%08X to_be_flushed\n",IF);
}else if(stall == 1){
fprintf(snp,"IF: 0x%08X to_be_stalled\n",IF);
}else fprintf(snp,"IF: 0x%08X\n",IF);
if(stall == 1){
fprintf(snp,"ID: %s to_be_stalled\n",ID);
}else if(for_Bie == 1){
fprintf(snp,"ID: %s fwd_ID_EX_r%c_$%d\n",ID,forad,fwdr);
}else if(for_B == 1){
fprintf(snp,"ID: %s fwd_EX-DM_r%c_$%d\n",ID,forad,fwdr);
}else fprintf(snp,"ID: %s\n",ID);
if(fwded == 1){
fprintf(snp,"EX: %s fwd_EX-DM_r%c_$%d\n",EX,fwdedad,fwdedr);
}else fprintf(snp,"EX: %s\n",EX);
fprintf(snp,"DM: %s\n",DM);
fprintf(snp,"WB: %s\n\n\n",WB);
if(PC%4 != 0)error_dm = 1;
i = (PC-inPC)/4;
cycle++;
}
return 0;
}
void BlueCoreDeviceController_newStyle::Implementation::checkQueues ()
{
PDU pdu(null_pdu);
for ( int i = 0 ; i < PDU::csr_hci_extensions_count ; ++i )
{
for ( int j = 0 ; j < 8 && pending[i]->getNextIfAvailable(pdu) ; ++j )
{
mConnectionToChip->sendpdu ( pdu );
if (pdu.channel() == PDU::hciACL)
aclDataTracker.removeData(pdu);
}
}
// deal with packets coming up...
for ( int j = 0 ; j < 8 && upstream.get( pdu ) ; ++j )
{
PDU::bc_channel ch = pdu.channel();
switch ( ch )
{
case PDU::bccmd:
pending[PDU::bccmd]->setToken();
break;
case PDU::hq :
{
if ( HQ_PDU(pdu).get_req_type() == HQPDU_SETREQ )
{
HQ_PDU ret ( pdu.clone () );
ret.set_req_type ( HQPDU_GETRESP );
pending[PDU::hq]->add(sae(ret,no_call_back));
}
break;
}
case PDU::hciCommand:
{
HCIEventPDU ev ( pdu );
switch ( ev.get_event_code() )
{
case HCI_EV_NUMBER_COMPLETED_PKTS:
{
HCI_EV_NUMBER_COMPLETED_PKTS_T_PDU ncp( pdu );
uint8 count = ncp.get_num_handles();
for ( uint8 i = 0 ; i < count ; ++i )
{
uint16 handle;
uint16 tokens;
ncp.get_num_completed_pkts(i,handle,tokens);
pending[PDU::hciACL]->incToken(tokens);
}
}
break;
case HCI_EV_COMMAND_COMPLETE:
{
HCICommandCompletePDU cc (pdu);
pending[PDU::hciCommand]->setToken(cc.get_num_hci_command_pkts() );
switch(cc.get_op_code())
{
case HCI_READ_VOICE_SETTING:
{
HCI_READ_VOICE_SETTING_RET_T_PDU rvs(pdu);
if ( rvs.get_status() == HCI_SUCCESS )
{
bool is_it_16 = (rvs.get_voice_setting()
& HCI_VOICE_SAMP_SIZE_MASK)
== HCI_VOICE_SAMP_SIZE_16BIT;
scoBandwidthTracker.set_audio_sample_size ( is_it_16 ? 16 : 8 );
}
}
break;
case HCI_READ_BUFFER_SIZE:
if ( !initialised_ACL_flow_control )
{
HCI_READ_BUFFER_SIZE_RET_T_PDU rbs ( pdu );
if ( rbs.get_status() == HCI_SUCCESS )
{
initialised_ACL_flow_control = true;
pending[PDU::hciACL]->setToken ( rbs.get_total_acl_data_pkts() );
}
}
break;
}
}
break;
case HCI_EV_COMMAND_STATUS:
{
HCI_EV_COMMAND_STATUS_T_PDU cc (pdu);
pending[PDU::hciCommand]->setToken(cc.get_num_hci_command_pkts() );
if (cc.get_op_code() == HCI_ADD_SCO_CONNECTION
&& cc.get_status() != HCI_COMMAND_CURRENTLY_PENDING )
{
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease());
}
}
break;
case HCI_EV_CONN_COMPLETE:
{
HCI_EV_CONN_COMPLETE_T_PDU cc(pdu);
if (cc.get_status() == HCI_SUCCESS)
{
if (cc.get_link_type() == HCI_LINK_TYPE_ACL)
aclDataTracker.addConnection(cc.get_handle());
else
{
// sco or esco. This will glitch if we were the initiating end.
getTransport()->set_sco_bandwidth(scoBandwidthTracker.consolidate(cc.get_handle()));
}
}
else
{
if (cc.get_link_type() == HCI_LINK_TYPE_SCO)
{
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease());
}
}
}
break;
case HCI_EV_DISCONNECT_COMPLETE:
{
HCI_EV_DISCONNECT_COMPLETE_T_PDU dc(pdu);
if ( dc.get_status() == HCI_SUCCESS )
{
uint16 h = dc.get_handle();
if (aclDataTracker.usingConnection(h))
aclDataTracker.removeConnection(h);
else
{
// sco or esco
getTransport()->set_sco_bandwidth(scoBandwidthTracker.decrease(h));
}
}
}
break;
case HCI_EV_SYNC_CONN_COMPLETE:
{
HCI_EV_SYNC_CONN_COMPLETE_T_PDU scc(pdu);
if ( scc.get_status() == HCI_SUCCESS )
{
// sco or esco. This will glitch if we were the initiating end.
getTransport()->set_sco_bandwidth(scoBandwidthTracker.consolidate(scc.get_handle()));
}
else
scoBandwidthTracker.decrease();
}
break;
case HCI_EV_LOOPBACK_COMMAND:
// we just had a command loop back, so allow us to send another.
pending[PDU::hciCommand]->setToken(1);
break;
default:
break;
}
break;
}
default:
break;
}
if ( !pending[ch]->run_callback(pdu) )
mReceiver.onPDU ( pdu );
// some stuff should be passed up... HQ and HCI only?
if ( mConnectionOnOffer )
{
switch ( ch )
{
case PDU::hq:
case PDU::hciCommand:
case PDU::hciACL:
case PDU::hciSCO:
(void)sendUp ( pdu );
break;
default:
// do nothing
break;
}
}
}
// accept requests from higher layers on all channels.
for ( int k = 0 ; k < 8 && downstream.get( pdu ) ; ++k )
{
switch ( pdu.channel() )
{
case PDU::hciCommand:
case PDU::hciACL:
case PDU::hciSCO:
(void)send ( sae ( pdu , perm_no_pass ) , true );
break;
default:
(void)send ( sae ( pdu , perm_pass_up ) , true );
break;
}
}
}
// Range类型支持
QVector<QVariant> MarshallRuby::VALUE2Variant2(VALUE v)
{
QVector<QVariant> rvs(1);
QVariant rv;
QString str, str2;
void *ci = NULL;
QObject *obj = NULL;
VALUE v1;
VALUE v2;
VALUE v3;
switch (TYPE(v)) {
case T_NONE: rv = QVariant(); break;
case T_FIXNUM: rv = (int)FIX2INT(v); break;
case T_STRING: rv = RSTRING_PTR(v); break;
case T_FLOAT: rv = RFLOAT_VALUE(v); break;
case T_NIL: rv = 0; break;
case T_TRUE: rv = true; break;
case T_FALSE: rv = false; break;
case T_OBJECT:
str = QString(rb_class2name(RBASIC_CLASS(v)));
ci = Qom::inst()->getObject(v);
// obj = dynamic_cast<QObject*>(ci);
qDebug()<<"unimpl VALUE:"<<str<<ci<<obj;
// rv = QVariant(QMetaType::VoidStar, ci);
rv = QVariant::fromValue(ci);
break;
case T_ARRAY: {
QStringList ary;
// ary << "a123" << "b3456";
qDebug()<<RARRAY_LEN(v)<<QT_VERSION;
for (int i = 0; i < RARRAY_LEN(v); i++) {
// FIXME: 也可能是对象数组，如Qt5::QString，但toString方法不好用。
// FIXME: 如，[Qt5::QApplication.translate("MainWindow", "acbc", nil), "efgggggg", "hijjjjjjjj"]
ary << VALUE2Variant(rb_ary_entry(v, i)).toString();
}
rv = QVariant(ary);
}; break;
case T_STRUCT: {
str = rb_class2name(RBASIC_CLASS(v));
if (str == "Range") {
// qDebug()<<"Range is struct???"<<BUILTIN_TYPE(v)
// <<rb_class2name(RBASIC_CLASS(v))
// <<RSTRUCT_LEN(v);
v1 = RSTRUCT_GET(v, 0);
v2 = RSTRUCT_GET(v, 1);
v3 = RSTRUCT_GET(v, 2);
// qDebug()<<TYPE(v1)<<TYPE(v2)<<TYPE(v3);
// qDebug()<<FIX2INT(v1)<<FIX2INT(v2);
rv = QVariant(FIX2INT(v1));
rvs.append(QVariant(FIX2INT(v2)));
} else {
qDebug()<<"unsupported struct type:"<<str;
}
}; break;
case T_CLASS:
default:
qDebug()<<"unknown VALUE type:"<<TYPE(v);
break;
}
rvs[0] = rv;
return (rvs);
}
void
Stokhos::KLReducedMatrixFreeOperator::
setup()
{
#ifdef HAVE_STOKHOS_ANASAZI
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos::KLReducedMatrixFreeOperator -- Calculation/setup of KL opeator");
#endif
mean = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(
block_ops->getCoeffPtr(0));
// Copy matrix coefficients into vectors
for (int coeff=0; coeff<num_blocks; coeff++) {
Teuchos::RCP<const Epetra_CrsMatrix> block_coeff =
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>
(block_ops->getCoeffPtr(coeff));
int row = 0;
for (int i=0; i<mean->NumMyRows(); i++) {
int num_col;
mean->NumMyRowEntries(i, num_col);
for (int j=0; j<num_col; j++)
(*block_vec_poly)[coeff][row++] = (*block_coeff)[i][j];
}
}
int myPID = sg_comm->MyPID();
// Compute KL expansion of solution sg_J_vec_poly
Stokhos::PCEAnasaziKL pceKL(*block_vec_poly, num_KL);
Teuchos::ParameterList anasazi_params = pceKL.getDefaultParams();
bool result = pceKL.computeKL(anasazi_params);
if (!result && myPID == 0)
std::cout << "KL Eigensolver did not converge!" << std::endl;
Teuchos::RCP<Epetra_MultiVector> evecs = pceKL.getEigenvectors();
Teuchos::Array<double> evals = pceKL.getEigenvalues();
//num_KL_computed = evecs->NumVectors();
if (myPID == 0)
std::cout << "num computed eigenvectors = "
<< evecs->NumVectors() << std::endl;
double kl_tol = params->get("KL Tolerance", 1e-6);
num_KL_computed = 0;
while (num_KL_computed < evals.size() &&
std::sqrt(evals[num_KL_computed]/evals[0]) > kl_tol)
num_KL_computed++;
if (num_KL_computed == evals.size() && myPID == 0)
std::cout << "Can't achieve KL tolerance " << kl_tol
<< ". Smallest eigenvalue / largest eigenvalue = "
<< std::sqrt(evals[num_KL_computed-1]/evals[0]) << std::endl;
if (myPID == 0)
std::cout << "num KL eigenvectors = " << num_KL_computed << std::endl;
// Compute dot products of Jacobian blocks and KL eigenvectors
dot_products.resize(num_KL_computed);
for (int rv=0; rv < num_KL_computed; rv++) {
dot_products[rv].resize(num_blocks-1);
for (int coeff=1; coeff < num_blocks; coeff++) {
double dot;
(*block_vec_poly)[coeff].Dot(*((*evecs)(rv)), &dot);
dot_products[rv][coeff-1] = dot;
}
}
// Compute KL coefficients
const Teuchos::Array<double>& norms = sg_basis->norm_squared();
sparse_kl_coeffs =
Teuchos::rcp(new Stokhos::Sparse3Tensor<int,double>);
for (Cijk_type::i_iterator i_it=Cijk->i_begin();
i_it!=Cijk->i_end(); ++i_it) {
int i = epetraCijk->GRID(index(i_it));
sparse_kl_coeffs->sum_term(i, i, 0, norms[i]);
}
Cijk_type::k_iterator l_begin = ++(Cijk->k_begin());
Cijk_type::k_iterator l_end = Cijk->k_end();
for (Cijk_type::k_iterator l_it=l_begin; l_it!=l_end; ++l_it) {
int l = index(l_it);
for (Cijk_type::kj_iterator j_it = Cijk->j_begin(l_it);
j_it != Cijk->j_end(l_it); ++j_it) {
int j = epetraCijk->GCID(index(j_it));
for (Cijk_type::kji_iterator i_it = Cijk->i_begin(j_it);
i_it != Cijk->i_end(j_it); ++i_it) {
int i = epetraCijk->GRID(index(i_it));
double c = value(i_it);
for (int k=1; k<num_KL_computed+1; k++) {
double dp = dot_products[k-1][l-1];
double v = dp*c;
if (std::abs(v) > drop_tolerance)
sparse_kl_coeffs->sum_term(i,j,k,v);
}
}
}
}
sparse_kl_coeffs->fillComplete();
bool save_tensor = params->get("Save Sparse 3 Tensor To File", false);
if (save_tensor) {
static int idx = 0;
std::string basename = params->get("Sparse 3 Tensor Base Filename",
"sparse_KL_coeffs");
std::stringstream ss;
ss << basename << "_" << idx++ << ".mm";
sparse3Tensor2MatrixMarket(*sparse_kl_coeffs,
*(epetraCijk->getStochasticRowMap()), ss.str());
}
// Transform eigenvectors back to matrices
kl_blocks.resize(num_KL_computed);
Teuchos::RCP<Epetra_BlockMap> kl_map =
Teuchos::rcp(new Epetra_LocalMap(num_KL_computed+1, 0,
sg_comm->TimeDomainComm()));
kl_ops =
Teuchos::rcp(new Stokhos::EpetraOperatorOrthogPoly(
sg_basis, kl_map, domain_base_map, range_base_map,
range_sg_map, sg_comm));
kl_ops->setCoeffPtr(0, mean);
for (int rv=0; rv<num_KL_computed; rv++) {
if (kl_blocks[rv] == Teuchos::null)
kl_blocks[rv] = Teuchos::rcp(new Epetra_CrsMatrix(*mean));
int row = 0;
for (int i=0; i<mean->NumMyRows(); i++) {
int num_col;
mean->NumMyRowEntries(i, num_col);
for (int j=0; j<num_col; j++)
(*kl_blocks[rv])[i][j] = (*evecs)[rv][row++];
}
kl_ops->setCoeffPtr(rv+1, kl_blocks[rv]);
}
Teuchos::RCP<Stokhos::EpetraSparse3Tensor> reducedEpetraCijk =
Teuchos::rcp(new Stokhos::EpetraSparse3Tensor(
sg_basis, sparse_kl_coeffs, sg_comm,
epetraCijk->getStochasticRowMap(), sparse_kl_coeffs,
0, -1));
reducedEpetraCijk->transformToLocal();
// Create matrix-free op
kl_mat_free_op = Teuchos::rcp(new Stokhos::MatrixFreeOperator(
sg_comm, sg_basis, reducedEpetraCijk,
domain_base_map, range_base_map,
domain_sg_map, range_sg_map, params));
kl_mat_free_op->setupOperator(kl_ops);
// Check accuracy of KL expansion
if (do_error_tests) {
Teuchos::Array<double> point(sg_basis->dimension());
for (int i=0; i<sg_basis->dimension(); i++)
point[i] = 0.5;
Teuchos::Array<double> basis_vals(sg_basis->size());
sg_basis->evaluateBases(point, basis_vals);
Epetra_Vector val(*block_vec_map);
Epetra_Vector val_kl(*block_vec_map);
block_vec_poly->evaluate(basis_vals, val);
val_kl.Update(1.0, (*block_vec_poly)[0], 0.0);
Teuchos::Array< Stokhos::OrthogPolyApprox<int,double> > rvs(num_KL_computed);
Teuchos::Array<double> val_rvs(num_KL_computed);
for (int rv=0; rv<num_KL_computed; rv++) {
rvs[rv].reset(sg_basis);
rvs[rv][0] = 0.0;
for (int coeff=1; coeff<num_blocks; coeff++)
rvs[rv][coeff] = dot_products[rv][coeff-1];
val_rvs[rv] = rvs[rv].evaluate(point, basis_vals);
val_kl.Update(val_rvs[rv], *((*evecs)(rv)), 1.0);
}
double nrm;
val.NormInf(&nrm);
val.Update(-1.0, val_kl, 1.0);
double diff;
val.NormInf(&diff);
if (myPID == 0)
std::cout << "Infinity norm of random field difference = " << diff/nrm
<< std::endl;
// Check accuracy of operator
Epetra_Vector op_input(*domain_sg_map), op_result(*range_sg_map), op_kl_result(*range_sg_map);
op_input.PutScalar(1.0);
Stokhos::MatrixFreeOperator op(sg_comm, sg_basis, epetraCijk,
domain_base_map, range_base_map,
domain_sg_map, range_sg_map, params);
op.setupOperator(block_ops);
op.Apply(op_input, op_result);
this->Apply(op_input, op_kl_result);
op_result.NormInf(&nrm);
op_result.Update(-1.0, op_kl_result, 1.0);
op_result.NormInf(&diff);
if (myPID == 0)
std::cout << "Infinity norm of operator difference = " << diff/nrm
<< std::endl;
}
#else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Stokhos::KLReducedMatrixFreeOperator is available " <<
"only when configured with Anasazi support!")
#endif
}
