void SymmetricRuizEquil
( Matrix<Field>& A,
Matrix<Base<Field>>& d,
Int maxIter, bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int n = A.Height();
Ones( d, n, 1 );
Matrix<Real> scales;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
EntrywiseMap( scales, MakeFunction(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
// TODO(poulson): Replace with SymmetricDiagonalSolve
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void SymmetricRuizEquil
( DistSparseMatrix<Field>& A,
DistMultiVec<Base<Field>>& d,
Int maxIter, bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int n = A.Height();
const Grid& grid = A.Grid();
d.SetGrid( grid );
Ones( d, n, 1 );
DistMultiVec<Real> scales(grid);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
EntrywiseMap( scales, MakeFunction(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
SymmetricDiagonalSolve( scales, A );
}
SetIndent( indent );
}
void StackedRuizEquil
( DistSparseMatrix<Field>& A,
DistSparseMatrix<Field>& B,
DistMultiVec<Base<Field>>& dRowA,
DistMultiVec<Base<Field>>& dRowB,
DistMultiVec<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int mA = A.Height();
const Int mB = B.Height();
const Int n = A.Width();
mpi::Comm comm = A.Comm();
dRowA.SetComm( comm );
dRowB.SetComm( comm );
dCol.SetComm( comm );
Ones( dRowA, mA, 1 );
Ones( dRowB, mB, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose to control structure
// For, simply hard-code a small number of iterations
const Int maxIter = 4;
DistMultiVec<Real> scales(comm), maxAbsValsB(comm);
auto& scalesLoc = scales.Matrix();
auto& maxAbsValsBLoc = maxAbsValsB.Matrix();
const Int localHeight = scalesLoc.Height();
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
ColumnMaxNorms( B, maxAbsValsB );
for( Int jLoc=0; jLoc<localHeight; ++jLoc )
scalesLoc(jLoc) = Max(scalesLoc(jLoc),maxAbsValsBLoc(jLoc));
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( RIGHT, NORMAL, scales, B );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowA );
DiagonalSolve( LEFT, NORMAL, scales, A );
RowMaxNorms( B, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowB );
DiagonalSolve( LEFT, NORMAL, scales, B );
}
SetIndent( indent );
}
void RuizEquil
( AbstractDistMatrix<Field>& APre,
AbstractDistMatrix<Base<Field>>& dRowPre,
AbstractDistMatrix<Base<Field>>& dColPre,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
ElementalProxyCtrl control;
control.colConstrain = true;
control.rowConstrain = true;
control.colAlign = 0;
control.rowAlign = 0;
DistMatrixReadWriteProxy<Field,Field,MC,MR> AProx( APre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dRowProx( dRowPre, control );
DistMatrixWriteProxy<Real,Real,MR,STAR> dColProx( dColPre, control );
auto& A = AProx.Get();
auto& dRow = dRowProx.Get();
auto& dCol = dColProx.Get();
const Int m = A.Height();
const Int n = A.Width();
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
DistMatrix<Real,MC,STAR> rowScale(A.Grid());
DistMatrix<Real,MR,STAR> colScale(A.Grid());
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRow );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
}
SetIndent( indent );
}
void StackedRuizEquil
( SparseMatrix<Field>& A,
SparseMatrix<Field>& B,
Matrix<Base<Field>>& dRowA,
Matrix<Base<Field>>& dRowB,
Matrix<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int mA = A.Height();
const Int mB = B.Height();
const Int n = A.Width();
Ones( dRowA, mA, 1 );
Ones( dRowB, mB, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
Matrix<Real> scales, maxAbsValsB;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
ColumnMaxNorms( B, maxAbsValsB );
for( Int j=0; j<n; ++j )
scales(j) = Max(scales(j),maxAbsValsB(j));
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( RIGHT, NORMAL, scales, B );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowA );
DiagonalSolve( LEFT, NORMAL, scales, A );
RowMaxNorms( B, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRowB );
DiagonalSolve( LEFT, NORMAL, scales, B );
}
SetIndent( indent );
}
void HermitianPseudoinverse
( UpperOrLower uplo, AbstractDistMatrix<Field>& APre, Base<Field> tolerance )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
DistMatrixReadWriteProxy<Field,Field,MC,MR> AProx( APre );
auto& A = AProx.Get();
const Grid& g = A.Grid();
// Get the EVD of A
// TODO(poulson): Use a relative eigenvalue lower-bound
DistMatrix<Real,VR,STAR> w(g);
DistMatrix<Field> Z(g);
HermitianEig( uplo, A, w, Z );
if( tolerance == Real(0) )
{
// Set the tolerance equal to n ||A||_2 eps
const Int n = Z.Height();
const Real eps = limits::Epsilon<Real>();
const Real twoNorm = MaxNorm( w );
tolerance = n*twoNorm*eps;
}
// Invert above the tolerance
auto omegaMap =
[=]( const Real& omega )
{ return ( omega < tolerance ? Real(0) : 1/omega ); };
EntrywiseMap( w, MakeFunction(omegaMap) );
// Form the pseudoinverse
HermitianFromEVD( uplo, A, w, Z );
}
void ASTConsumer::AddMethodDecl(clang::NamedDecl* decl, const std::string& name, const std::string& parent_name)
{
// Cast to a method
clang::CXXMethodDecl* method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl);
assert(method_decl != 0 && "Failed to cast to C++ method declaration");
// Ignore overloaded operators for now
if (method_decl->isOverloadedOperator())
return;
std::vector<cldb::Field> parameters;
if (method_decl->isInstance())
{
// Parse the 'this' type, treating it as the first parameter to the method
cldb::Field this_param;
Status status = MakeField(*this, method_decl->getThisType(m_ASTContext), "this", name, 0, this_param, MF_CHECK_TYPE_IS_REFLECTED);
if (status.HasWarnings())
{
status.Print(method_decl->getLocation(), m_ASTContext.getSourceManager(), va("Failed to reflect method '%s' due to invalid 'this' type", name.c_str()));
return;
}
parameters.push_back(this_param);
}
// Parse and add the method
MakeFunction(decl, name, parent_name, parameters);
}
void HermitianPseudoinverse
( UpperOrLower uplo, Matrix<Field>& A, Base<Field> tolerance )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
// Get the EVD of A
// TODO(poulson): Use a relative eigenvalue lower bound
Matrix<Real> w;
Matrix<Field> Z;
HermitianEig( uplo, A, w, Z );
if( tolerance == Real(0) )
{
// Set the tolerance equal to n ||A||_2 eps
const Int n = Z.Height();
const Real eps = limits::Epsilon<Real>();
const Real twoNorm = MaxNorm( w );
tolerance = n*twoNorm*eps;
}
// Invert above the tolerance
auto omegaMap =
[=]( const Real& omega )
{ return ( omega < tolerance ? Real(0) : 1/omega ); };
EntrywiseMap( w, MakeFunction(omegaMap) );
// Form the pseudoinverse
HermitianFromEVD( uplo, A, w, Z );
}
Handle<JSFunction> Compiler::Compile(Handle<String> source,
Handle<Object> script_name,
int line_offset, int column_offset,
v8::Extension* extension,
ScriptDataImpl* input_pre_data) {
int source_length = source->length();
Counters::total_load_size.Increment(source_length);
Counters::total_compile_size.Increment(source_length);
// The VM is in the COMPILER state until exiting this function.
VMState state(COMPILER);
// Do a lookup in the compilation cache but not for extensions.
Handle<JSFunction> result;
if (extension == NULL) {
result = CompilationCache::LookupScript(source,
script_name,
line_offset,
column_offset);
}
if (result.is_null()) {
// No cache entry found. Do pre-parsing and compile the script.
ScriptDataImpl* pre_data = input_pre_data;
if (pre_data == NULL && source_length >= FLAG_min_preparse_length) {
Access<SafeStringInputBuffer> buf(&safe_string_input_buffer);
buf->Reset(source.location());
pre_data = PreParse(source, buf.value(), extension);
}
// Create a script object describing the script to be compiled.
Handle<Script> script = Factory::NewScript(source);
if (!script_name.is_null()) {
script->set_name(*script_name);
script->set_line_offset(Smi::FromInt(line_offset));
script->set_column_offset(Smi::FromInt(column_offset));
}
// Compile the function and add it to the cache.
result = MakeFunction(true,
false,
DONT_VALIDATE_JSON,
script,
Handle<Context>::null(),
extension,
pre_data);
if (extension == NULL && !result.is_null()) {
CompilationCache::PutScript(source, result);
}
// Get rid of the pre-parsing data (if necessary).
if (input_pre_data == NULL && pre_data != NULL) {
delete pre_data;
}
}
if (result.is_null()) Top::ReportPendingMessages();
return result;
}
void FinalSnapshot
( const Matrix<Real>& estimates,
const Matrix<Int>& itCounts,
SnapshotCtrl& snapCtrl )
{
EL_DEBUG_CSE
auto logMap = []( const Real& alpha ) { return Log(alpha); };
if( snapCtrl.realSize != 0 && snapCtrl.imagSize != 0 )
{
const bool numSave = ( snapCtrl.numSaveFreq >= 0 );
const bool imgSave = ( snapCtrl.imgSaveFreq >= 0 );
const bool imgDisp = ( snapCtrl.imgDispFreq >= 0 );
Matrix<Real> estMap;
Matrix<Int> itCountMap;
if( numSave || imgSave || imgDisp )
{
ReshapeIntoGrid
( snapCtrl.realSize, snapCtrl.imagSize, estimates, estMap );
if( snapCtrl.itCounts )
ReshapeIntoGrid
( snapCtrl.realSize, snapCtrl.imagSize, itCounts, itCountMap );
}
if( numSave )
{
string base = snapCtrl.numBase;
Write( estMap, base, snapCtrl.numFormat );
if( snapCtrl.itCounts )
Write( itCountMap, base+"_counts", snapCtrl.numFormat );
}
if( imgSave || imgDisp )
EntrywiseMap( estMap, MakeFunction(logMap) );
if( imgSave )
{
string base = snapCtrl.imgBase;
Write( estMap, base, snapCtrl.imgFormat );
if( snapCtrl.itCounts )
Write( itCountMap, base+"_counts", snapCtrl.imgFormat );
auto colorMap = GetColorMap();
SetColorMap( GRAYSCALE_DISCRETE );
Write( estMap, base+"_discrete", snapCtrl.imgFormat );
SetColorMap( colorMap );
}
if( imgDisp )
{
string base = snapCtrl.imgBase;
Display( estMap, base );
if( snapCtrl.itCounts )
Display( itCountMap, base+"_counts" );
auto colorMap = GetColorMap();
SetColorMap( GRAYSCALE_DISCRETE );
Display( estMap, base+"_discrete" );
SetColorMap( colorMap );
}
}
}
void RuizEquil
( DistSparseMatrix<Field>& A,
DistMultiVec<Base<Field>>& dRow,
DistMultiVec<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
mpi::Comm comm = A.Comm();
dRow.SetComm( comm );
dCol.SetComm( comm );
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose to control structure
// For, simply hard-code a small number of iterations
const Int maxIter = 4;
DistMultiVec<Real> scales(comm);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRow );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void SymmetricRuizEquil
( AbstractDistMatrix<Field>& APre,
AbstractDistMatrix<Base<Field>>& dPre,
Int maxIter, bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
ElementalProxyCtrl control;
control.colConstrain = true;
control.rowConstrain = true;
control.colAlign = 0;
control.rowAlign = 0;
DistMatrixReadWriteProxy<Field,Field,MC,MR> AProx( APre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dProx( dPre, control );
auto& A = AProx.Get();
auto& d = dProx.Get();
const Int n = A.Height();
Ones( d, n, 1 );
DistMatrix<Real,MR,STAR> scales(A.Grid());
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns (and rows)
// ------------------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
EntrywiseMap( scales, MakeFunction(SquareRootScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, d );
// TODO(poulson): Replace with SymmetricDiagonalSolve
DiagonalSolve( RIGHT, NORMAL, scales, A );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void RuizEquil
( Matrix<Field>& A,
Matrix<Base<Field>>& dRow,
Matrix<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
Matrix<Real> rowScale, colScale;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRow );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
}
SetIndent( indent );
}
Handle<JSFunction> Compiler::CompileEval(Handle<String> source,
Handle<Context> context,
bool is_global,
ValidationState validate) {
// Note that if validation is required then no path through this
// function is allowed to return a value without validating that
// the input is legal json.
int source_length = source->length();
Counters::total_eval_size.Increment(source_length);
Counters::total_compile_size.Increment(source_length);
// The VM is in the COMPILER state until exiting this function.
VMState state(COMPILER);
// Do a lookup in the compilation cache; if the entry is not there,
// invoke the compiler and add the result to the cache. If we're
// evaluating json we bypass the cache since we can't be sure a
// potential value in the cache has been validated.
Handle<JSFunction> result;
if (validate == DONT_VALIDATE_JSON)
result = CompilationCache::LookupEval(source, context, is_global);
if (result.is_null()) {
// Create a script object describing the script to be compiled.
Handle<Script> script = Factory::NewScript(source);
result = MakeFunction(is_global,
true,
validate,
script,
context,
NULL,
NULL);
if (!result.is_null() && validate != VALIDATE_JSON) {
// For json it's unlikely that we'll ever see exactly the same
// string again so we don't use the compilation cache.
CompilationCache::PutEval(source, context, is_global, result);
}
}
return result;
}
void AsmSysMakeInlineAsmFunc( bool too_many_bytes )
/*************************************************/
{
int code_length;
SYM_HANDLE sym_handle;
TREEPTR tree;
bool uses_auto;
char name[8];
/* unused parameters */ (void)too_many_bytes;
code_length = AsmCodeAddress;
if( code_length != 0 ) {
sprintf( name, "F.%d", AsmFuncNum );
++AsmFuncNum;
CreateAux( name );
CurrInfo = (aux_info *)CMemAlloc( sizeof( aux_info ) );
*CurrInfo = WatcallInfo;
CurrInfo->use = 1;
CurrInfo->save = AsmRegsSaved; // indicate no registers saved
uses_auto = InsertFixups( AsmCodeBuffer, code_length, &CurrInfo->code );
if( uses_auto ) {
/*
We want to force the calling routine to set up a [E]BP frame
for the use of this pragma. This is done by saying the pragma
modifies the [E]SP register. A kludge, but it works.
*/
HW_CTurnOff( CurrInfo->save, HW_SP );
}
CurrEntry->info = CurrInfo;
CurrEntry->next = AuxList;
AuxList = CurrEntry;
CurrEntry = NULL;
sym_handle = MakeFunction( name, FuncNode( GetType( TYPE_VOID ), FLAG_NONE, NULL ) );
tree = LeafNode( OPR_FUNCNAME );
tree->op.u2.sym_handle = sym_handle;
tree = ExprNode( tree, OPR_CALL, NULL );
tree->u.expr_type = GetType( TYPE_VOID );
AddStmt( tree );
}
}
bool CSerializePrxToIdc::SerializeExport(int num, const PspLibExport *exp)
{
char str_export[128];
int iLoop;
u32 addr;
snprintf(str_export, sizeof(str_export), "export_%d", num);
addr = exp->addr;
if(exp->stub.name != 0)
{
MakeOffset(m_fpOut, str_export, addr);
MakeString(m_fpOut, BuildName(str_export, "name"), exp->stub.name);
}
else
{
MakeDword(m_fpOut, str_export, addr);
}
MakeDword(m_fpOut, BuildName(str_export, "flags"), addr+4);
MakeDword(m_fpOut, BuildName(str_export, "counts"), addr+8);
MakeOffset(m_fpOut, BuildName(str_export, "exports"), addr+12);
for(iLoop = 0; iLoop < exp->f_count; iLoop++)
{
MakeDword(m_fpOut, BuildName(str_export, exp->funcs[iLoop].name), exp->funcs[iLoop].nid_addr);
MakeOffset(m_fpOut, "", exp->funcs[iLoop].nid_addr + ((exp->v_count + exp->f_count) * 4));
MakeFunction(m_fpOut, exp->funcs[iLoop].name, exp->funcs[iLoop].addr);
}
for(iLoop = 0; iLoop < exp->v_count; iLoop++)
{
MakeDword(m_fpOut, BuildName(str_export, exp->vars[iLoop].name), exp->vars[iLoop].nid_addr);
MakeOffset(m_fpOut, "", exp->vars[iLoop].nid_addr + ((exp->v_count + exp->f_count) * 4));
}
return true;
}
void Snapshot
( const Matrix<Int>& preimage,
const Matrix<Real>& estimates,
const Matrix<Int>& itCounts,
Int numIts,
bool deflate,
SnapshotCtrl& snapCtrl )
{
EL_DEBUG_CSE
auto logMap = []( const Real& alpha ) { return Log(alpha); };
if( snapCtrl.realSize != 0 && snapCtrl.imagSize != 0 )
{
const bool numSave =
( snapCtrl.numSaveFreq > 0 &&
snapCtrl.numSaveCount >= snapCtrl.numSaveFreq );
const bool imgSave =
( snapCtrl.imgSaveFreq > 0 &&
snapCtrl.imgSaveCount >= snapCtrl.imgSaveFreq );
const bool imgDisp =
( snapCtrl.imgDispFreq > 0 &&
snapCtrl.imgDispCount >= snapCtrl.imgDispFreq );
Matrix<Real> invNorms, estMap;
Matrix<Int> itCountsReord, itCountMap;
if( numSave || imgSave || imgDisp )
{
invNorms = estimates;
if( deflate )
RestoreOrdering( preimage, invNorms );
ReshapeIntoGrid
( snapCtrl.realSize, snapCtrl.imagSize, invNorms, estMap );
if( snapCtrl.itCounts )
{
itCountsReord = itCounts;
if( deflate )
RestoreOrdering( preimage, itCountsReord );
ReshapeIntoGrid
( snapCtrl.realSize, snapCtrl.imagSize, itCountsReord,
itCountMap );
}
}
if( numSave )
{
auto title = BuildString( snapCtrl.numBase, "_", numIts );
Write( estMap, title, snapCtrl.numFormat );
if( snapCtrl.itCounts )
Write( itCountMap, title+"_counts", snapCtrl.numFormat );
snapCtrl.numSaveCount = 0;
}
if( imgSave || imgDisp )
EntrywiseMap( estMap, MakeFunction(logMap) );
if( imgSave )
{
auto title = BuildString( snapCtrl.imgBase, "_", numIts );
Write( estMap, title, snapCtrl.imgFormat );
if( snapCtrl.itCounts )
Write( itCountMap, title+"_counts", snapCtrl.imgFormat );
auto colorMap = GetColorMap();
SetColorMap( GRAYSCALE_DISCRETE );
Write( estMap, title+"_discrete", snapCtrl.imgFormat );
SetColorMap( colorMap );
snapCtrl.imgSaveCount = 0;
}
if( imgDisp )
{
auto title = BuildString( snapCtrl.imgBase, "_", numIts );
Display( estMap, title );
if( snapCtrl.itCounts )
Display( itCountMap, title+"_counts" );
auto colorMap = GetColorMap();
SetColorMap( GRAYSCALE_DISCRETE );
Display( estMap, title+"_discrete" );
SetColorMap( colorMap );
snapCtrl.imgDispCount = 0;
}
}
}
JSFunction::JSFunction(const JSContext& js_context, const JSString& body, const std::vector<JSString>& parameter_names, const JSString& function_name, const JSString& source_url, int starting_line_number)
: JSObject(js_context, MakeFunction(js_context, body, parameter_names, function_name, source_url, starting_line_number)) {
}
void ASTConsumer::AddFunctionDecl(clang::NamedDecl* decl, const std::string& name, const std::string& parent_name)
{
// Parse and add the function
std::vector<cldb::Field> parameters;
MakeFunction(decl, name, parent_name, parameters);
}
Type* Type::Read(Buffer *buf)
{
uint32_t kind = 0;
uint32_t width = 0;
uint32_t count = 0;
bool sign = false;
bool varargs = false;
String *name = NULL;
Type *target_type = NULL;
TypeCSU *csu_type = NULL;
Vector<Type*> argument_types;
Try(ReadOpenTag(buf, TAG_Type));
while (!ReadCloseTag(buf, TAG_Type)) {
switch (PeekOpenTag(buf)) {
case TAG_Kind: {
Try(!kind);
Try(ReadTagUInt32(buf, TAG_Kind, &kind));
break;
}
case TAG_Width: {
Try(ReadTagUInt32(buf, TAG_Width, &width));
break;
}
case TAG_Sign: {
Try(ReadTagEmpty(buf, TAG_Sign));
sign = true;
break;
}
case TAG_Name: {
Try(!name);
Try(kind == YK_CSU);
name = String::ReadWithTag(buf, TAG_Name);
break;
}
case TAG_Type: {
Try(!target_type);
Try(kind == YK_Pointer || kind == YK_Array || kind == YK_Function);
target_type = Type::Read(buf);
break;
}
case TAG_Count: {
Try(kind == YK_Array);
Try(ReadTagUInt32(buf, TAG_Count, &count));
break;
}
case TAG_TypeFunctionCSU: {
Try(!csu_type);
Try(ReadOpenTag(buf, TAG_TypeFunctionCSU));
csu_type = Type::Read(buf)->AsCSU();
Try(ReadCloseTag(buf, TAG_TypeFunctionCSU));
break;
}
case TAG_TypeFunctionVarArgs: {
Try(kind == YK_Function);
Try(ReadTagEmpty(buf, TAG_TypeFunctionVarArgs));
varargs = true;
break;
}
case TAG_TypeFunctionArguments: {
Try(kind == YK_Function);
Try(argument_types.Empty());
Try(ReadOpenTag(buf, TAG_TypeFunctionArguments));
while (!ReadCloseTag(buf, TAG_TypeFunctionArguments)) {
Type *ntype = Type::Read(buf);
argument_types.PushBack(ntype);
}
break;
}
default:
Try(false);
}
}
switch ((TypeKind)kind) {
case YK_Error:
return MakeError();
case YK_Void:
return MakeVoid();
case YK_Int:
return MakeInt(width, sign);
case YK_Float:
return MakeFloat(width);
case YK_Pointer:
Try(target_type);
return MakePointer(target_type, width);
case YK_Array:
Try(target_type);
return MakeArray(target_type, count);
case YK_CSU:
Try(name);
return MakeCSU(name);
case YK_Function:
Try(target_type);
return MakeFunction(target_type, csu_type, varargs, argument_types);
default:
Try(false);
}
}
void Ridge
( Orientation orientation,
const Matrix<Field>& A,
const Matrix<Field>& B,
Base<Field> gamma,
Matrix<Field>& X,
RidgeAlg alg )
{
EL_DEBUG_CSE
const bool normal = ( orientation==NORMAL );
const Int m = ( normal ? A.Height() : A.Width() );
const Int n = ( normal ? A.Width() : A.Height() );
if( orientation == TRANSPOSE && IsComplex<Field>::value )
LogicError("Transpose version of complex Ridge not yet supported");
if( m >= n )
{
Matrix<Field> Z;
if( alg == RIDGE_CHOLESKY )
{
if( orientation == NORMAL )
Herk( LOWER, ADJOINT, Base<Field>(1), A, Z );
else
Herk( LOWER, NORMAL, Base<Field>(1), A, Z );
ShiftDiagonal( Z, Field(gamma*gamma) );
Cholesky( LOWER, Z );
if( orientation == NORMAL )
Gemm( ADJOINT, NORMAL, Field(1), A, B, X );
else
Gemm( NORMAL, NORMAL, Field(1), A, B, X );
cholesky::SolveAfter( LOWER, NORMAL, Z, X );
}
else if( alg == RIDGE_QR )
{
Zeros( Z, m+n, n );
auto ZT = Z( IR(0,m), IR(0,n) );
auto ZB = Z( IR(m,m+n), IR(0,n) );
if( orientation == NORMAL )
ZT = A;
else
Adjoint( A, ZT );
FillDiagonal( ZB, Field(gamma) );
// NOTE: This QR factorization could exploit the upper-triangular
// structure of the diagonal matrix ZB
qr::ExplicitTriang( Z );
if( orientation == NORMAL )
Gemm( ADJOINT, NORMAL, Field(1), A, B, X );
else
Gemm( NORMAL, NORMAL, Field(1), A, B, X );
cholesky::SolveAfter( LOWER, NORMAL, Z, X );
}
else
{
Matrix<Field> U, V;
Matrix<Base<Field>> s;
if( orientation == NORMAL )
{
SVDCtrl<Base<Field>> ctrl;
ctrl.overwrite = false;
SVD( A, U, s, V, ctrl );
}
else
{
Matrix<Field> AAdj;
Adjoint( A, AAdj );
SVDCtrl<Base<Field>> ctrl;
ctrl.overwrite = true;
SVD( AAdj, U, s, V, ctrl );
}
auto sigmaMap =
[=]( const Base<Field>& sigma )
{ return sigma / (sigma*sigma + gamma*gamma); };
EntrywiseMap( s, MakeFunction(sigmaMap) );
Gemm( ADJOINT, NORMAL, Field(1), U, B, X );
DiagonalScale( LEFT, NORMAL, s, X );
U = X;
Gemm( NORMAL, NORMAL, Field(1), V, U, X );
}
}
else
{
LogicError("This case not yet supported");
}
}
void ImagPart
( const AbstractDistMatrix<T>& A, AbstractDistMatrix<Base<T>>& AImag )
{
auto imagPart = []( const T& alpha ) { return ImagPart(alpha); };
EntrywiseMap( A, AImag, MakeFunction(imagPart) );
}