bool MatrixZero::Mp_StM(
MatrixOp* m_lhs, value_type alpha
, BLAS_Cpp::Transp trans_rhs) const
{
assert_initialized();
return true; // Nothing to do!
}
void MatrixZero::Vp_StMtV(
VectorMutable* y, value_type alpha, BLAS_Cpp::Transp trans_rhs1
, const SpVectorSlice& x, value_type b) const
{
assert_initialized();
Vt_S(y,b);
}
value_type MatrixZero::transVtMtV(
const SpVectorSlice& sv_rhs1, BLAS_Cpp::Transp trans_rhs2
, const SpVectorSlice& sv_rhs3) const
{
assert_initialized();
return 0.0; // Nothing to do!
}
void MatrixZero::Vp_StMtV(
VectorMutable* y, value_type a, BLAS_Cpp::Transp M_trans_in
, const Vector& x, value_type b
) const
{
assert_initialized();
Vt_S(y,b);
}
bool MatrixZero::syrk(
BLAS_Cpp::Transp M_trans, value_type alpha
, value_type beta, MatrixSymOp* sym_lhs ) const
{
assert_initialized();
sym_lhs->Mt_S(beta);
return true;
}
bool MatrixZero::Mp_StPtM(
MatrixOp* m_lhs, value_type alpha
, const GenPermMatrixSlice& P_rhs, BLAS_Cpp::Transp P_rhs_trans
, BLAS_Cpp::Transp M_trans
) const
{
assert_initialized();
return true; // Nothing to do!
}
bool MatrixZero::Mp_StMtM(
MatrixOp* m_lhs, value_type alpha
, const MatrixOp& mwo_rhs1, BLAS_Cpp::Transp trans_rhs1
, BLAS_Cpp::Transp trans_rhs2, value_type beta ) const
{
assert_initialized();
m_lhs->Mt_S(beta);
return true;
}
void MatrixZero::syr2k(
BLAS_Cpp::Transp M_trans, value_type alpha
, const GenPermMatrixSlice& P1, BLAS_Cpp::Transp P1_trans
, const GenPermMatrixSlice& P2, BLAS_Cpp::Transp P2_trans
, value_type beta, MatrixSymOp* sym_lhs ) const
{
assert_initialized();
sym_lhs->Mt_S(beta);
}
void MatrixZero::Vp_StPtMtV(
VectorMutable* y, value_type alpha
, const GenPermMatrixSlice& P_rhs1, BLAS_Cpp::Transp P_rhs1_trans
, BLAS_Cpp::Transp M_rhs2_trans
, const SpVectorSlice& x, value_type b) const
{
assert_initialized();
Vt_S(y,b);
}
const DVectorSlice QPInitFixedFreeStd::fo() const
{
assert_initialized();
return fo_;
}
const MatrixSymOpNonsing& QPInitFixedFreeStd::Ko() const
{
assert_initialized();
return *Ko_;
}
const GenPermMatrixSlice& QPInitFixedFreeStd::Q_X() const
{
assert_initialized();
return Q_X_;
}
const DVectorSlice QPInitFixedFreeStd::b_X() const
{
assert_initialized();
return b_X_;
}
const QP::i_x_X_map_t& QPInitFixedFreeStd::i_x_X_map() const
{
assert_initialized();
return i_x_X_map_;
}
const QP::x_init_t& QPInitFixedFreeStd::x_init() const
{
assert_initialized();
return x_init_;
}
size_type QPInitFixedFreeStd::n_R() const
{
assert_initialized();
return n_R_;
}
const MatrixSymOp& QPInitFixedFreeStd::G() const
{
assert_initialized();
return *G_;
}
size_type QPInitFixedFreeStd::m() const
{
assert_initialized();
return m_;
}
const VectorSpace& MatrixZero::space_cols() const
{
assert_initialized();
return *space_cols_;
}
void MatrixZero::Mt_S( value_type alpha )
{
assert_initialized();
// Automatically satisfied!
}
const Constraints& QPInitFixedFreeStd::constraints() const
{
assert_initialized();
return *constraints_;
}
MatrixOp& MatrixZero::operator=(const MatrixOp& M)
{
assert_initialized();
TEUCHOS_TEST_FOR_EXCEPT(true); // ToDo: Implement!
return *this;
}
std::ostream& MatrixZero::output(std::ostream& out) const
{
assert_initialized();
return out << "Zero matrix of dimension " << rows() << " x " << cols() << std::endl;
}
/*
* StartOS API call.
* This service is called to start the operating system in a specific mode.
*/
void os_StartOS(AppModeType appmode)
{
os_ipl save_ipl;
OS_SAVE_IPL(save_ipl); /* Save IPL on entry so can restore on exit, side-effect: assigns back to save_ipl */
ENTER_KERNEL_DIRECT(); /* Set IPL to kernel level while setting up OS variables etc. */
OS_API_TRACE_START_OS();
INIT_STACKCHECK_TO_OFF(); /* Make sure stack checking is turned off so that when/if dispatch() is called there are no stack errors
* Note that this requires the kernel stack (i.e. main()'s stack) is big enough to support this call to
* StartOS plus a call to dispatch() and the entry into the subsequent task
*/
#ifndef NDEBUG
assert_initialized(); /* assert the C runtime startup has setup all vars to startup state */
#endif
/* Saving a jmp_buf (os_startosenv) so that the entire OS can be terminated via a longjmp call inside a ShutdownOS call */
/* $Req: artf1216 artf1219 $ */
if (SETJMP(os_startosenv) == 0) {
/* This half of the 'if' is the half that is the run-on continuation */
/* $Req: artf1214 artf1094 $ */
os_appmode = appmode; /* Store application mode in which the OS was started */
/* setup the tasks and alarms that are to be autostarted for the given app mode */
start_tasks(appmode);
/* Initialize all counters in the system to start running */
start_counters();
/* Autostart alarms */
if(appmode->start_alarms_singleton) {
appmode->start_alarms_singleton(appmode);
}
if(appmode->start_alarms_multi) {
appmode->start_alarms_multi(appmode);
}
/* Autostarted schedule tables are autostarted implicitly by the underlying alarms being autostarted */
#ifdef STACK_CHECKING
os_curtos = OS_KS_TOP;
#endif
/* Call startup hook if required to do so */
/* $Req: artf1215 $ */
if (os_flags.startuphook) { /* check if need to call the startuphook handler */
/* hook needs calling */
ENABLE_STACKCHECK(); /* enable stack checking */
/* @todo check that we really need to raise IPL to lock out all interrupts (both CAT1 and CAT2) within the hook */
OS_SET_IPL_MAX(); /* raise IPL to lock out all interrupts (both CAT1 and CAT2) within the hook */
MARK_OUT_KERNEL(); /* drop out of the kernel, keeping IPL at max level */
/* $Req: artf1117 $ */
StartupHook(); /* call the hook routine with IPL set to kernel level and stack checking on */
MARK_IN_KERNEL(); /* go back into the kernel */
OS_SET_IPL_KERNEL(); /* set IPL back to kernel level */
DISABLE_STACKCHECK(); /* disable stack checking */
}
/* Start the scheduling activity */
if (TASK_SWITCH_PENDING(os_curpri)) {
os_ks_dispatch();
}
ENABLE_STACKCHECK();
LEAVE_KERNEL();
/* now running as the body of the os_idle task, with IPL at level 0 and priority of IDLEPRI */
/* $Req: artf1116 $ */
/* Note that interrupts will be enabled prior to here because the os_ks_dispatch() call above
* might switch to running autostarted tasks, which will lower interrupts to level 0
*/
for ( ; ; ) {
os_idle(); /* call the os_idle task entry function */
}
NOT_REACHED();
}
else {
/* This half of the 'if' is the half that is RETURNING from a longjmp */
/* We have come back from a ShutdownOS() call */
}
/* Reached here because ShutdownOS(E_OK) was called.
*
* $Req: artf1219 $
*/
assert(KERNEL_LOCKED());
assert(STACKCHECK_OFF()); /* Stack checking turned off prior to longjmp in shutdown() */
/* Would normally stop the counters, reinitialise the kernel variables, etc. in case StartOS() were to be called again,
* but OS424 (artf1375) requires that StartOS() doesn't return, but instead goes into an infinite loop.
* Similarly, OS425 (artf1376) requires that interrupts are disabled before entering the loop.
*
* If StartOS() is ever required to return to caller, see revision 568 of this file (startos.c) for the
* original code that did this.
*
* $Req: artf1375 $
* $Req: artf1376 $
*/
OS_SET_IPL_MAX();
for(;;)
;
}
void MatrixZero::zero_out()
{
assert_initialized();
// Automatically satisfied!
}