pub fn fixedpoint<F, T>(&self, constructor: F) -> Result<T, SchedulerError>
    where
        F: FnOnce(&mut Circuit<Self>) -> Result<T, SchedulerError>,
    {
        self.fixedpoint_with_scheduler::<F, T, DynamicScheduler>(constructor)
    }
/// Add a child circuit that will iterate to a fixed point.
///
/// For each parent clock cycle, the child circuit will iterate until
/// reaching a fixed point, i.e., a state where the outputs of all
/// operators are guaranteed to remain the same, should the nested clock
/// continue ticking.
///
/// The fixed point check is implemented by checking the following
/// condition:
///
/// * All operators in the circuit are in such a state that, if their inputs
///   remain constant (i.e., all future inputs are identical to the last
///   input), then their outputs remain constant too.
///
/// This is a necessary and sufficient condition that is also easy to check
/// by asking each operator if it is in a stable state (via the
/// [`Operator::fixedpoint`](`super::operator_traits::Operator::fixedpoint`)
/// API.  
///
/// # Warning
///
/// The cost of checking this condition precisely can be high for some
/// operators, which implement approximate checks instead.  For instance,
/// delay operators ([`Z1`](`crate::operator::Z1`) and
/// [`Z1Nested`](`crate::operator::Z1Nested`)) require storing the last
/// two versions of the state instead of one and comparing them at each
/// cycle.  Instead, they conservatively check for _specific_ fixed points,
/// namely fixed points where both input and output of the operator are zero
/// As a result, the circuit may fail to detect other fixed points and may
/// iterate forever.
///
/// The goal is to evolve the design so that circuits created using the
/// high-level API (`Stream::xxx` methods) implement accurate fixed point
/// checks, but there are currently no guardrails in the system against
/// constructing non-compliant circuits.
Add a child circuit that will iterate to a fixed point.
For each parent clock cycle, the child circuit will iterate until
reaching a fixed point, i.e., a state where the outputs of all
operators are guaranteed to remain the same, should the nested clock
continue ticking.

The fixed point check is implemented by checking the following
condition.

All operators in the circuit are in such a state that, if their inputs
remain constant , then their outputs remain constant too.


Add a child circuit that will iterate to a fixed point . For each parent clock cycle the child circuit will iterate until reaching a fixed point i . e . a state where the outputs of all operators are guaranteed to remain the same should the nested clock continue ticking . The fixed point check is implemented by checking the following condition . All operators in the circuit are in such a state that if their inputs remain constant then their outputs remain constant too .
pub fn fixedpoint<F, T>(&self, constructor: F) -> Result<T, SchedulerError>
    where
        F: FnOnce(&mut Circuit<Self>) -> Result<T, SchedulerError>,
    {
        self.fixedpoint_with_scheduler::<F, T, DynamicScheduler>(constructor)
    }
pub fn fixedpoint < F , T > ( & self , constructor : F ) -> Result < T , SchedulerError > where F : FnOnce ( & mut Circuit < Self > ) -> Result < T , SchedulerError > , { self . fixedpoint_with_scheduler :: < F , T , DynamicScheduler > ( constructor ) }
Add a child circuit that will iterate to a fixed point.
Add a child circuit that will iterate to a fixed point .
&self
constructor
F
warning
The cost of checking this condition precisely can be high for some
operators, which implement approximate checks instead.  For instance,
delay operators ([`Z1`](`crate::operator::Z1`) and
[`Z1Nested`](`crate::operator::Z1Nested`)) require storing the last
two versions of the state instead of one and comparing them at each
cycle.  Instead, they conservatively check for _specific_ fixed points,
namely fixed points where both input and output of the operator are zero
As a result, the circuit may fail to detect other fixed points and may
iterate forever.

The goal is to evolve the design so that circuits created using the
high-level API (`Stream::xxx` methods) implement accurate fixed point
checks, but there are currently no guardrails in the system against
constructing non-compliant circuits.
The cost of checking this condition precisely can be high for some operators which implement approximate checks instead . For instance delay operators ( [ ` Z1 ` ] ( ` crate :: operator :: Z1 ` ) and [ ` Z1Nested ` ] ( ` crate :: operator :: Z1Nested ` )) require storing the last two versions of the state instead of one and comparing them at each cycle . Instead they conservatively check for _specific_ fixed points namely fixed points where both input and output of the operator are zero As a result the circuit may fail to detect other fixed points and may iterate forever . The goal is to evolve the design so that circuits created using the high - level API ( ` Stream :: xxx ` methods ) implement accurate fixed point checks but there are currently no guardrails in the system against constructing non - compliant circuits .