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;
}
예제 #24
0
파일: startos.c 프로젝트: jkenergy/scalios
/* 
 * 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!
}