text:
# 6. Activity 1.2: Co-simulation and Model Exchange Using the FMI Standard¶

## 6.1. Introduction¶

### 6.1.1. Motivation for Coupled Simulation¶

Currently, there is a significant number of sophisticated simulation models and tools available for use in building energy simulation. Models and parametrization are provided by different specialists, with some models being the outcome of many years of development. Hence, different programming languages and modeling approaches are used.

Often, a tool misses functionality provided by others. For many applications it is desirable to use several simulation tools concurrently and make use of results generated by the different models. Consequently, tools running transient simulations often need results generated by other models at runtime. For example, a building energy simulation model computing room air temperatures may require heating loads from an HVAC supply system, with the latter coming from a simulation model external to the building simulation tool.

Pure integration of several existing models into a single simulation tool is technically very difficult, in particular since many tools include their own numerical solver engines and calculation algorithms. Moreover, different simulation tools manage their internal data differently, which further complicates their integration. Also, given different authors, domain experts, copyright limitations, etc. an integration into a single tool may not be meaningful or possible at all. Lastly, future development and maintenance of such an integral model may be difficult to organize. It is also difficult to ensure lasting financial support for development and maintenance of a complex integral simulation tool authored by many individual developers.

Translating existing models into modular equation-based languages such as Modelica could be considered as an alternative, and could benefit from modern Modelica features. Modular, hierarchical design could be used and Modelica tools would be able to optimize the system of resulting equations for performance. However, this approach may not be economically feasible regarding the expected overhead of translating a large number of existing models, and their documentation. Also, copyright and intellectual property protection may not permit integrating their existing model code.

As an alternative, new and existing code of complex systems can be decomposed into sub-systems, the subsystems simulated with the simulator which suits best the specific domain, and interface variables exchanged as the simulation progresses.

Co-simulation is a technique in which simulators are executed simultaneously while exchanging data during run-time. In this context we refer to simulators, also called slaves, as individual component models described by differential algebraic or discrete equations.

The simulators typically embed systems with differential-algebraic equations. Each simulator may implement different numerical techniques tailored to a specific physical or mathematical problem. This includes the possibility that through usage of special programming language features, memory layout, parallelization or other specific optimization, the specialized implementation for model equations may perform better than an equivalent model in a generic simulation environment.

### 6.1.2. Need for a Tool Coupling Standard¶

When considering coupled simulation of different tools, several options are available:

1. When access to source code is possible, or tool developers can work actively together, tools may interface directly. Simulation tool developers may even incorporate calculation capability from another tool into their own code. Such a procedure depends on many prerequisites, such as compatible programming languages, proper license agreements, data and calculation structure compatibility and sufficient developer resources. In many cases the resulting code can be considered as a new integrated tool and not really a coupled tool.
2. In the one-to-one approach, two tools implement a specific protocol that regulates exchange of data during runtime. This approach is the most flexible and can support any kind of numerical solution method and also take into account peculiarities of the tools involved. However, the implementation may need to be continuously updated when one of the tools evolves. Also, if tools are developed independently, testing and checking of correct functionality may become time-consuming. Furthermore, interfacing with a third tool typically requires reformulation or adaptation of the protocol and effectively implementing another coupling mechanism tailored to the new tool. Lastly, the development of a clear application programming interface (API) specification and the semantics of the tool coupling is difficult, and subsequent revisions to this API may incur large development costs.
3. To overcome the need for, potentially many, one-to-one exchange protocol implementations a middleware could be used. This acts as a hub for several tools that interface with it and relays communicated data to other connected tools. This approach is less flexible than the one-to-one approach, since a common ground on interface capability needs to be agreed upon. When interfacing domain-specific tools, the middleware can be fitted to the specifics of the problem types and applied numerical methods. Tools need to implement only a single interface and communication protocol and only need to revise code when the middleware is upgraded. However, the same problem regarding the API specification as for the one-to-one approach remains.

In the past, many tool coupling technologies have been developed and applied, with different mathematical concepts and programming interfaces. Many have been tool-specific proprietary interfaces that may change frequently as the original tool developers see fit. Further, the details of interfaces are often restricted to certain applications and lack functionality needed in other physical domains. This is particularly true for domain-specific middleware approaches. In addition, closed-source middleware implementation details may change from version to version, thus potentially render previously connected tools incompatible.

To overcome these limitations it was necessary to develop an open-source and community driven standard for coupled simulation. In 2008 the Modelisar project started to develop such a standard, named the Functional Mockup Interface (FMI, https://www.fmi-standard.org/). Finally, with the initial 1.0 release, a standard for interfacing simulation tools has become available. See [BOA+11] for an introductory paper and https://www.fmi-standard.org/literature for various literature about FMI.

### 6.1.3. Overview of the FMI Standard¶

The FMI standard describes the mathematical concept for coupled simulation of several simulators, called Functional Mockup Units (FMU). The FMI standard defines the following:

1. A set of C-functions (FMI functions) that allow exchange of data between FMUs. The standard defines the signature of these function, their required behavior, e.g., the semantics, and it also prescribes during what state of the simulation these functions can or must be called.
2. An XML scheme that is used by each FMU to publish meta-data of the model and the simulator. These data are stored in a file called modelDescription.xml. It contains meta-data such as the number and type of variables to be exchanged and integrated, the capabilities of the simulator, and the mathematical structure the FMU.
3. A zip file with extension fmu that is used to package the XML file, the compiled binaries with the implemented FMI functions, optionally the original source code, as well as resources (databases, project parameters, etc.) required to execute the model.

The FMI standard allows two modes of encapsulating a model: model-exchange and co-simulation. The next sections describe these modes.

### 6.1.4. Mathematical Aspects of Model Exchange and Co-Simulation¶

With respect to solving the coupled system of equations arising from all FMUs within one simulation system, two different approaches are standardized. The first, called model exchange, requires a central time integration algorithm that solves collectively the system of differential-algebraic equations defined within the FMUs.

The second approach, called co-simulation, defines a methodology for interconnecting different encapsulated models and numerical solution methods. The individual FMUs incorporate their own integration method that may be tailored towards the physical problem to solve. Also, existing simulator engines can be re-used by implementing a co-simulation interface. The co-simulation master algorithm needs to ensure agreement of all exchanged variables, i.e. that variables computed by one FMU and used by another are correctly synchronized among the tools.

The next sections describe FMI for model exchange and co-simulation, then describe how to synchronize FMUs with a master algorithm, and finally how to generate or export FMUs.

### 6.1.5. Functional Mockup Interface for Model Exchange¶

The mathematical concept behind FMI for Model Exchange is based on the idea that a model can be formulated as a function whose output depends on parameters, input variables, state variables and time. Parameters are values that do not change with time. They are assigned at the start of the simulation. Inputs are values that can change with time.

Consider the example illustrated in Fig. 6.1.

The corresponding Modelica code illustrates the functionality of the model:

  1 2 3 4 5 6 7 8 9 10 11 model RoomModel parameter Real C "Room heat capacity in J/K"; parameter Real K "Heat loss coefficient in W/K"; input Real TOut "Outdoor air temperature in K"; input Real P "Heat added to the room in W"; output Real Q_flow "Heat exchange with the ambient in W"; Real T(start=293.15) "Room air temperature in K"; equation Q_flow = K * ( TOut - T); C * der(T) = Q_flow + P; end RoomModel;

Suppose now a user wants to incorporate this model into a Model Exchange FMU. The inputs to the model are $$u = (T_{out}, P)$$, the state is $$T$$, the state derivative is $$dT/dt$$, and the requested output is the heat exchange with the ambient $$\dot Q = K \, (T_{out} - T)$$. The actual calculation code looks like:

 1 2 3 4 5 6 7 // We have cached the state variable T and // inputs TOut and P. // Compute the output. Q_flow = K * ( TOut - T); // Compute the time derivative. dT_dt = (Q_flow + P) / C;

The implementation of the physics of such a model is fairly simple. The model obtains input, caches the state variable and computes the output and time derivative. The time integration will be managed by the simulation master and is not a task of the model. Therefore, no solver to integrate the ordinary differential equation through time needs to be implemented. However, model developers must bear in mind that there is no notion of time step size. Also, the model implementation must not make the assumption that time is always increasing, since the simulation master may request the model to be evaluated several times at the same time, or even requested to go back to a past time instant. See Section 6.1.7 for more detail.

The FMI standard defines a state-machine approach for evaluation of the functions that set inputs, update states, compute outputs, etc. This means, that the model is not evaluated through a single function call passing the complete set of input variables and expecting all outputs and states at once. Instead, the model is treated as an object with a state.

The state of an FMU is only modified when input variables or the time are changed by invoking the FMI functions. While the FMI standard prescribes when the state of the object and outputs are updated, the model can make use of efficient implementation. For example, in our implementation above, if the input P is updated but TOut and T remains unchanged, then Q_flow = K * ( TOut - T) need not be recomputed, saving unnecessary model computation time.

In the model implemented above, all outputs can readily be evaluated without any iteration. However, some FMUs may involve equations that form an algebraic loop. For example, an FMU may implement a hydraulic network which requires an iterative solution to compute pressures and mass flow rate. In this situation, the numerical algorithm to solve such an algebraic loop, typically a Newton-Raphson method, needs to be part of the FMU. Alternatively, the model can be split into two FMUs, and the task of resolving algebraic loops may be delegated to the master algorithm (see Section 6.1.7).

### 6.1.6. Functional Mockup Interface for Co-Simulation¶

Co-Simulation describes a calculation method that requires each simulator to integrate its own model equations over a time interval requested by the master algorithm, and exchange outputs only at certain time instants called the communication points. At these communication points, the master algorithm retrieves output variables, and distributes them to other FMUs that use these outputs as inputs. Once the inputs have been updated, the master requests each FMU to integrate to the next communication point. If a simulator cannot advance time to the next communication point, for example because its error would be too large, or because an event happened inside the simulator, it can report this to the master algorithm, which then may request other FMUs to redo their time integration over a shorter time interval.

Co-simulation slaves are, similar to Model Exchange simulators, state objects. The key difference is that for model-exchange, FMUs output the time derivatives of their continuous-time state variables, whereas for co-simulation, FMUs need to integrated this states themselves and output the new values of the state variables.

If the room model example from the previous section is implemented as an FMU for co-simulation, the time integration needs to be performed manually. In the example code below, a simple explicit Euler Integration is implemented:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // We are requested to integrate over the communication // interval with length h beginning at current time t. // The FMU state T is stored at time t. // We have cached the inputs TOut and P at time t // which are treated constant over the interval t...t+h. steps = h/dt; // number of integration steps for (unsigned int i=0; i < steps; ++i) { // compute time derivative Q_flow = K * ( TOut - T); // Update the state T = T + dt * ((Q_flow + P) / C); }

Note that the explicit Euler integration algorithm with fixed time step size may be inefficient. During the time integration from one communication time step to the next, the FMU assumes its inputs to be constant, while in actuality, they may vary more frequently through time. Hence, large communication time steps can incur large errors of the co-simulation.

For example, consider again the thermal room model example above. Suppose the heat added to the room P is computed by a heating system in another FMU. The heater may be controlled by the room temperature and reduce heating power when the set point temperature is approached. The room model provides the room temperature as output. At the beginning of the communication interval, this temperature is passed as input to the heating model, and being below the set point temperature, a heating power is computed. This heating power is then passed to the room model. During the time integration of the room model, this heating power remains constant, and may eventually lead to a room temperature above the set point temperature, as illustrated in Fig. 6.2 [1].

While the co-simulation method is a flexible tool coupling approach, it is important to control communication interval sizes and implement suitable algorithms that handle events and control the numerical error of the coupled equations.

### 6.1.7. Master Algorithms¶

We will now describe simple master algorithms for model exchange and for co-simulation. Master algorithms synchronize the different FMUs, assign inputs to FMUs, and in the case of model exchange, also provide solvers for differential equations and algebraic equations that are formed by connecting FMUs.

Model exchange master algorithms need to solve systems of differential algebraic equations (DAE). Typically, master algorithms provide different choices for such solvers. When solving the DAEs, the FMU is treated as a mathematical function that computes outputs and time derivatives for given time, inputs and states.

We will now use the FMU example model from Section 6.1.5 to illustrate a simple model exchange master algorithm. An instantiated FMU, named simulation slave, is evaluated in a time integration loop that is the core of the Model Exchange master algorithm. In the following example, an Explicit Euler integration method is used with a predefined number of integration steps:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 // ... the FMU slave is instantiated and initialized // We have stored the initial state of the FMU // in the variable x. // The instance m is a pointer to the model. // Set constant time step sizes based on selected // steps in the master. double dt = (t_end - t_start)/steps; // integrate for (unsigned int i = 0; i < steps; ++i) { // Set new time. M_fmi2SetTime(m, t_start + dt * i); // Set inputs. M_fmi2SetReal(m, ..., &TOut); M_fmi2SetReal(m, ..., &P); // Set state variables M_fmi2SetContinuousStates(m, &T, 1); // Retrieve the computed time derivative. M_fmi2GetDerivatives(&dT_dt); // Integrate in time. T = T + dt * dT_dt; }

In general, a more sophisticated integration algorithm is needed to ensure that the integration error remains below a user-prescribed tolerance, to handle time events and state events, and to integrate the equations more efficiently. Typically, an adaptive time step method is used that adapts the integration time step based on an estimate of the integration error and events. Furthermore, if algebraic loops are present, the master algorithm needs to provide a linear or nonlinear solver. Such algebraic loops are formed if the outputs and inputs of an FMU have direct dependency, and the inputs and outputs with direct dependency are connected with each other.

Implicit time integration methods and nonlinear equation solvers typically use a Newton-Raphson algorithm. Since the Newton-Raphson algorithm builds a Jacobian matrix that has the same dimension as the number of variables, this operation can be computationally expensive. The use of sparse Jacobian matrices is helpful, but requires information on dependencies of individual variables on others. The ability for an FMU to publish such dependency information has been added to the FMI standard in version 2.0. The information about dependency also allows usage of efficient asynchronous numerical time integration algorithms such as Quantized State Systems (QSS) methods [ZL98][Kof03][FK14].

Co-simulation master algorithms assign inputs to outputs of other FMUs, assign the requested time step to FMUs, and advance time of the co-simulation. Hence, each FMU is responsible for integrating in time its continuous-time state variables from the current time to the next communication time point.

Next, we illustrate a basic co-simulation master algorithm with a simple example. Suppose, the room model example above was complemented by a controlled heating model which takes the room air temperature as input and computes the required power of the heating unit based on a temperature setpoint. The heating model and the room model both hold a state at a certain time point. Advancing from this time point to the next communication point can be managed by the co-simulation master algorithm as follows:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 // The FMU slaves are instantiated and initialized. // s1 is the room model, and s2 is the heater model // Both FMU slaves are at time t and the master algorithm // has cached the output variables of both slaves. t = startTime; h = communicationTimeStep; // Loop over all slaves. while(tc < stopTime && status1 == fmi2OK && status2 == fmi2OK) // Retrieve outputs. s1_fmi2GetReal(s1, ..., 1, &T); s2_fmi2GetReal(s2, ..., 1, &P); // Set inputs. s1_fmi2SetReal(s1, ..., 1, &P); s2_fmi2SetReal(s2, ..., 1, &T); // Advance time. status1 = s1_fmi2DoStep(s1, t, h, fmi2True); status2 = s2_fmi2DoStep(s2, t, h, fmi2True); // Increment master time. t += h; }

In this example, the master algorithm retrieves outputs, assigns them as inputs to the other FMU, and then requests the FMUs to advance time. Not shown in this example is error handling, as well as handling the situation in which an FMU may reject to advance time to t+h.

The choice of the co-simulation master algorithm can have a great impact on overall performance, as well as on the correctness of the result, in particular in the presence of an event. To ensure that the results of co-simulations of hybrid systems are deterministic and, hence, equal regardless of the tool that implements the master algorithm, [BGL+15] provides requirements and a test suite with expected results that can be used to verify correctness of master algorithms.

### 6.1.8. Exporting and Importing of Functional Mockup Units¶

Simulation programs may generate and export FMUs. During FMU export, the simulation model is exposed in such a way that it can be used with the FMI functions for model exchange or co-simulation. The result of the FMU export is a zip file, called the FMU file, as described in Section 6.1.3.

A simulation master or a simulation environment needs to import FMUs in order to use them. Importing FMUs consist of extracting the FMU file, parsing the modelDescription.xml file, and connecting the internal data structure with the FMI functions provided by the FMU. Through these FMI functions, the master or the simulation environment will interact with the model that was provided inside the FMU.

## 6.2. Use Cases and Applications¶

Having explained the FMI standard and its philosophy of use, we will now present typical use cases and applications in the design and operation of building and district energy systems in which utilizing FMI offers interesting and innovative perspectives. We will present typical and generic use cases, as well as specific applications that were developed by participants of this activity.

### 6.2.1. Simulation-Based Building Operation¶

This use case describes how FMI can be applied to monitor the actual performance of a building relative to the design intent during operation.

During the design, an HVAC designer creates a simulation model of a building, including its HVAC system and controls. The designer then exports the model as an FMU for co-simulation and imports it into a building management system (BMS) such as NiagaraAX. In the BMS, the designer links the model input to measured data. The design model can then be used to compute expected room air temperature or energy consumption, which in turn can be used to compare measured with expected performance. Details of these steps are as follows:

• As a first step, the HVAC engineer develops a model of the building and its HVAC and control system in a modeling language such as Modelica.

• As a second step, the HVAC engineer simulates the building model along with its HVAC and control system to ensure correctness of the control sequence.

Optionally, to verify the control sequence, the HVAC response and the building response, the model could be decomposed into these three subsystems: Measured data could be fed into the control model to verify actual versus expected control actions; the control signals of the actual system, together with measured outdoor and room conditions could be sent to the HVAC model to verify actual versus expected HVAC efficiency; and the measured HVAC supply conditions and outdoor conditions could be sent to the building model to verify actual versus expected energy provided to the rooms.

• As a third step, the model of the building with its HVAC and control sequence is exported as an FMU for co-simulation and imported into the building management system. The exported system model can then run in real-time to compute the expected performance of the building.

### 6.2.2. Design and Operational Analysis of Energy, Control and Communication Grids¶

Buildings as components of an energy system consume, store and produce energy. In order to provide more global energy efficient solutions and to facilitate the integration of intermittent energy resources, one should consider the interaction of clusters of buildings with the electrical, gas and, if district heating or cooling is present, thermal networks. Such energy grids may have overlying centralized or distributed control, coupled through communication networks.

Such networks are complex systems composed of multi-disciplinary, multi-physics components that can be difficult to handle by any one functional domain: energy assets, information and communication technology and business processes. Energy assets (electrical components, buildings and HVAC systems, industrial processes, thermodynamics) are conveniently described by differential algebraic equations. In other domains, typically for information and communication technology, components are more conveniently expressed by event-based modeling (e.g. representing a market that negotiates energy prices and energy allotments, messaging among distributed equipment, and switching devices).

For such a wide functional scope, a monolithic approach that uses one model with one global solver may require simplified or reduced order models to be computationally tractable. In contrast, distributed simulation, possibly with different numerical solvers for the different domains, is a promising alternative to simulate large systems in parallel. The FMI standard provides a programming interface for models that allows this distributed simulation. Moreover, by encapsulating the domains in FMUs, domain-specific tools may be reused, such as for the simulation of large electrical networks that connect the buildings.

To setup such a distributed simulation, the following four steps are typically done:

1. Generate the models representing the buildings, grid components, control and communication.
2. Export the models as FMUs.
3. Connected the FMUs in a master algorithm, possibly using distributed computing.
4. Control the simulation with a master algorithm.

### 6.2.3. Co-Simulation via Domus with Modelica, EnergyPlus and ANSYS CFX¶

During the IEA Annex 60 project, the research version of Domus, Domus-r, described in Section 6.5.7, has been improved for co-simulation. For EnergyPlus and Modelica, an FMI for co-simulation import interface has been added, while for ANSYS-CFX a script-based interface has been added. In a tool-coupling test case with EnergyPlus, a pure conductive heat transfer envelope model was encapsulated as an FMU for co-simulation and imported into Domus, with the objective to validate the Domus FMI interface.

The Domus pixel counting technique (Fig. 6.4 a) has been used for accurate and fast evaluation of complex shading at internal and external surfaces. The intention of this use case was to simulate the effect that complex shading has on building energy use, with the latter being computed in EnergyPlus.

As a first step of a Domus co-simulation with CFD, Domus has been used to co-simulate with ANSYS-CFX a hollowed block (Fig. 6.4 b) wall. The results are promising and demonstrate a functional integration between Domus and CFX that can expand the current limits of both simulation tools and allow 3-D simulation of building elements.The introduction of the co-simulation in Domus enables detailed, combined consideration of the three heat transfer modes calculated by CFX and integration of this with different tools such as EnergyPlus and Modelica. This would allow for assessment of indoor air quality and building energy efficiency under asymmetric indoor and outdoor boundary conditions. Nevertheless, the high computer run time for CFD is still a considerable constraint so that further research is needed to make it viable.

## 6.3. FMI-Compliant Tools for Buildings and District Simulation¶

This section provides an overview of FMI-compliant simulation tools that are either specifically developed for, or useful for, building simulation. While the majority of these tools have been developed outside of Annex 60, they are listed here to guide new users. A more comprehensive list of those that support the FMI standard can be found on the FMI-Standard website (https://www.fmi-standard.org/tools).

Dymola (http://www.3ds.com/products-services/catia/products/dymola/) is an environment that supports modeling and simulation of multi-physics systems implemented in the Modelica language. Dymola can be used to import and export models as FMUs for both co-simulation and model exchange.

JModelica (http://www.jmodelica.org/) is a Modelica-based open source platform for optimization, simulation and analysis of complex dynamic systems. JModelica has been used by the building simulation community for the simulation and optimization of building energy systems. It supports the export and import for FMUs for model exchange and for co-simulation using the PyFMI Python package.

OpenModelica (https://openmodelica.org/) is an open-source Modelica-based modeling and simulation environment. It has been used in the building community for the modeling and simulation of building energy systems. It supports the export and import for FMUs for both model exchange and co-simulation.

SimulationX (https://www.simulationx.com/) is a modeling and simulation tool which can be used for energy efficiency and HVAC systems modeling and simulation. It supports the export and import of FMUs for both co-simulation and model exchange.

MATLAB/Simulink (http://mathworks.com/products/simulink/) also support FMI import and export using the Modelon FMI toolbox (http://www.modelon.com/products/fmi-toolbox-for-matlab/). A building application case and some implementation comparisons can be found in [WJEP15].

Ptolemy II is an open-source software framework [Pto14] supporting experimentation with actor-oriented design. Actors are software components that execute concurrently and communicate through messages sent via interconnected ports. Ptolemy II has been used to create the Building Controls Virtual Test Bed (BCVTB) [Wet11a]. Ptolemy II supports the import of FMUs which implement FMI 1.0 and 2.0 for co-simulation and model exchange. A large district energy system co-simulation has been implemented in [ZJB+16].

PyFMI (https://pypi.python.org/pypi/PyFMI) is a python package for loading and interfacing with FMUs for co-simulation and model exchange. PyFMI is available as a stand-alone package or as part of the JModelica.org distribution. PyFMI has been used by the building simulation community for applications such as fault detection and diagnostics, and model predictive controls. A building co-simulation example using Dymola models can be found in [RRDW15].

MasterSim (http://mastersim.sourceforge.net) is a co-simulation master algorithm implementation and graphical user interface written in C/C++ (Windows/Mac/Unix) for coupled simulation of FMUs using FMI 2.0. It supports error controlled co-simulation and iterative master algorithms that set and get the state variables.

EnergyPlus (https://energyplus.net/) is a whole building energy simulation program that engineers, architects, and researchers use to model energy consumption for heating, cooling, ventilation, lighting and plug and process loads, as well as water use in buildings. Import and export of model FMUs are available for co-simulation [NWZ14]. Numerous applications can be found in the literature, see for example [DEP16][ZJB+16].

WUFI+ (https://wufi.de/en/software/wufi-plus/) is a hygrothermal whole building simulation program which supports the import of FMUs for co-simulation [PBR+12]. The FMU import functionality was added to integrate Modelica HVAC system models to WUFI.

TRNSYS (http://www.trnsys.com/) is a graphically-based software environment used to simulate the behavior of transient systems. Even though TRNSYS itself does not officially provide FMI support, there is a dedicated FMI-based tool coupling solution openly available at http://trnsys-fmu.sourceforge.net. Furthermore, the feasibility of importing FMUs in TRNSYS through a TRNSYS Type has been demonstrated in [EWP+13][EAWP13].

DIgSILENT PowerFactory (http://www.digsilent.com/) is a state-of-the-art industrial-grade modeling and simulation tool for electrical networks. Even though PowerFactory itself does not officially provide FMI support, it provides several APIs for co-simulation and there is a dedicated FMI-based tool-coupling solution openly available (see http://powerfactory-fmu.sourceforge.net) that utilizes these APIs in an FMI-compliant way.

## 6.4. FMU Export Facilities¶

This section describes software packages that can be used to export FMUs and were developed by participants of the Annex 60.

### 6.4.1. THERAKLES (Room Model)¶

THERAKLES (http://www.bauklimatik-dresden.de/therakles) is a single-zone hygrothermal model with detailed construction models developed at the Institute for Building Climate Control of the TU Dresden. It includes basic equipment component models. It provides modeling of the thermal storage of the wall by use of spatial discretization techniques. Focusing on deployment in engineering practice, it also provides a user-friendly graphical user interface.

For simulation with more advanced equipment and control logic, the THERAKLES model can be exported as an FMU for model exchange and co-simulation according to the FMI 2.0 standard. A graphical dialog is provided to lead the user through the export process. The generated FMUs provide reset functionality for state variables. Thus, all exported FMUs support error-controlled co-simulation.

THERAKLES has its own climate data base and exports calculated climatic data during simulation. The climate model is encapsulated in the CCM-library which supports an internal binary data format but also reads and converts data from *.epw file format.

### 6.4.2. NANDRAD (Building Energy Simulation/Multizone)¶

NANDRAD (http://www.bauklimatik-dresden.de/nandrad) is a building energy simulation framework developed at the Institute for Building Climate Control at TU Dresden. The NANDRAD tool is a command line application designed for the efficient simulation of complex buildings, including detailed wall models. The resulting large differential equation system is solved by state-of-the-art numerical methods, such as Newton-Krylov-iteration methods and sparse matrix algorithms.

NANDRAD supports FMU export for FMI 2.0 co-simulation and model exchange by a script-based automated procedure. The provided input and output interfaces allow the coupling between the NANDRAD building simulation and an external HVAC model, for example a heating or a hydraulic cycle Modelica model. The import of the FMU into a Modelica environment is directly supported by an automatically generated wrapper model. This wrapper encapsulates the NANDRAD FMU, connects all inputs and outputs with vector valued ports and generates a graphical representation. Additionally, NANDRAD precalculates heating and cooling design data and publishes it in a report file.

Similar to THERAKLES, the NANDRAD FMUs support getting and setting of state variables and climate data export.

### 6.4.3. EnergyplusToFMU¶

EnergyPlusToFMU (https://github.com/lbl-srg/EnergyplusToFMU) is a software package written in Python that allows users to export the building simulation program EnergyPlus version 8.0 or higher as an FMU for co-simulation using the FMI standard version 1.0. This FMU can then be imported into a variety of simulation programs that can import a FMU for co-simulation. This capability allows, for instance, for modeling the envelope of a building in EnergyPlus, exporting the model as an FMU, and then importing and linking the model with an HVAC system model developed in a system simulation tool such as the Modelica environment Dymola. EnergyPlusToFMU is released under an open-source BSD-license.

### 6.4.4. FMI++ TRNSYS FMU Export Utility¶

Even though TRNSYS itself does not officially provide FMI support, there is a dedicated FMI-based tool coupling solution openly available, called the FMI++ TRNSYS FMU Export Utility. It has been developed using the FMI++ library (see http://fmipp.sourceforge.net/) and enables the export of a TRNSYS model with a Python script as an FMU for co-simulation, using FMI 1.0.

The export tool provides to modelers a special TRNSYS block called Type6139. This type provides external data sent to TRNSYS as inputs to the model and also allows for sending data as external outputs. Apart from the additional input and output block of this type, TRNSYS models are constructed in the usual way as shown in Fig. 6.6.

The FMI++ TRNSYS FMU Export Utility is released under an open-source BSD-license and is available at http://trnsys-fmu.sourceforge.net

### 6.4.5. FMI++ PowerFactory FMU Export Utility¶

The FMI++ PowerFactory FMU Export Utility is a stand-alone tool for exporting FMUs for Co-Simulation (FMI Version 1.0) from DIgSILENT PowerFactory models, based on code from the FMI++ library (see http://fmipp.sourceforge.net/). It provides a Python script that creates FMUs from certain PowerFactory models, including the XML model description and shared libraries. Additional files (e.g., time series files) and start values for exported variables can be specified. Currently only steady-state simulations are supported, where the system evolution with respect to time comprises a series of load flow snapshots.

The FMI++ PowerFactory FMU Export Utility is released under an open-source BSD-license, available at http://powerfactory-fmu.sourceforge.net

## 6.5. Simulation Environments and Master Algorithms for FMI¶

This section describes simulation environments with FMU import facilities and master algorithms that have been developed by Annex 60 participants. It also describes numerical methods that have been implemented to integrate in time FMUs for model exchange.

### 6.5.1. Building Controls Virtual Test Bed¶

The Building Controls Virtual Test Bed (BCVTB) is a free, open-source middleware based on Ptolemy II (http://ptolemy.eecs.berkeley.edu/). It allows users to couple different simulation tools for data exchange during run-time and for real-time simulation. Programs that are linked to the BCVTB are

1. EnergyPlus, the whole building energy simulation program,
2. Dymola, the Modelica modeling and simulation environment,
3. Functional Mock-up Units (FMU) for co-simulation and model-exchange for the Functional Mock-up Interface (FMI) 1.0 and 2.0,
4. MATLAB and Simulink tools for scientific computing,
5. Radiance, the ray-tracing software for lighting analysis,
6. ESP-r, the integrated building energy modeling program,
7. TRNSYS, the system simulation program,
8. BACnet stack, which allows exchanging data with BACnet compliant Building Automation System (BAS),
9. USB-1208LS, the analog/digital interface from Measurement Computing Corporation that can be connected to a USB port.

Fig. 6.7 shows its graphical user interface with a co-simulation model.

The BCVTB has been used in several applications such as agent-based simulation, real-time simulation, control of networked sensors and actuators, and performance prediction of HVAC systems. The BCVTB is released under an open-source BSD license and available at http://simulationresearch.lbl.gov/bcvtb. For more information, see [Wet11a].

### 6.5.2. EnergyPlus¶

EnergyPlus (https://energyplus.net/) is a whole building energy simulation program that engineers, architects, and researchers use to model both energy consumption and water use in buildings. To extend the capability of EnergyPlus for building simulation, EnergyPlus has been linked through co-simulation to various programs using direct coupling of tools through custom interfaces and through master algorithms in which EnergyPlus acts as a client.

To address the limitation of these custom coupling mechanisms, an FMI for co-simulation 1.0 import interface has been added to EnergyPlus to support the import of FMUs. Also, a facility has been developed to export EnergyPlus as an FMU for co-simulation 1.0. This interface allows users to link the building envelope of EnergyPlus with an HVAC system modeled in Modelica, or in another simulation tool and language. EnergyPlus is released under an open-source BSD license, and available at https://github.com/NREL/EnergyPlus. For more information, see http://simulationresearch.lbl.gov/fmu/EnergyPlus/export and [NWZ14].

### 6.5.3. DACCOSIM¶

DACCOSIM lets you design and execute a simulation composed of multiple FMUs on multi-core computation nodes or distributed on clusters.

A framework is provided to graphically define how the FMUs are connected to each others and on which computation nodes they should be distributed. DACCOSIM automatically generates the associated code and the DACCOSIM library is then used to execute the multi-simulation on the distributed computation nodes. It could be either Java or C++ code.

The main functionalities provided by DACCOSIM are

1. co-initialization with the Newton-Raphson method,
2. inputs extrapolation,
3. support for both constant and variable step size with rollback,
4. various error estimation methods that automatically adjust the step size (Euler, Richardson and Adams-Bashforth),

It runs on Windows and Linux, 32-bits and 64-bits and uses FMI-CS. It is developed by the Supelec IDMaD research team and the EDF R&D MIRE department in the RISEGrid Institute (http://www.supelec.fr/342_p_38091/risegrid-en.html).

DACCOSIM is released under the AGPL open-source license and available at http://daccosim.foundry.supelec.fr/.

### 6.5.4. Ptolemy II and Quantized State Systems (QSS)¶

Ptolemy II provides a master algorithm for FMUs for model-exchange and co-simulation, which implements the FMI 2.0 specification.

The master algorithm is implemented in the discrete event domain of Ptolemy II. Additionally, a family of Quantized State System (QSS) integrators is provided to integrate state variables of FMUs for model exchange 2.0. Details about the master algorithm and the QSS integrator can be found in [WNL+15]. The algorithm is release as part of Ptolemy II, and also in the cyber-physical system simulator CyPhySim [LNNW15][BLL+15], which is a subset of Ptolemy II. Both are available under a BSD-license from http://ptolemy.eecs.berkeley.edu/ptolemyII/ and https://chess.eecs.berkeley.edu/cyphysim/.

The CyPhySim simulator supports classical (Runge-Kutta) and quantized-state simulation of ordinary differential equations, modal models (hybrid systems), discrete-event models, the Functional Mockup Interface (FMI) for model-exchange and co-simulation, discrete-time systems, and algebraic loop solvers. CyPhySim provides a graphical editor, an XML file syntax for models, and an open API for programmatic construction of models. It includes an innovation called smooth tokens, which allow for a blend of numerical and symbolic computation, and for certain kinds of system models, dramatically reducing the computation required for simulation. For example, Fig. 6.9 shows a model of a bouncing ball implemented in the CyPhySim simulator. For this problem, a Runge-Kutta 2-3 solver required 14,072 time steps and 3.3 seconds, while QSS required only 46 points in time and completed in 0.085 seconds, or 38 times faster. Furthermore, the QSS solvers have the interesting property that if certain assumptions about the integrator inputs are satisfied, then rollback is never required. If these assumptions are valid, then there is no error due to numerical approximation of the integration, and events such as zero crossings are predictable in advance. For certain cyber-physical systems, such assumptions are indeed valid, and hence computationally exact simulation is possible, where the only source of errors is numerical round-off errors. There is no error due to numerical integration. See [LNNW15] for more details.

### 6.5.5. FUMOLA - The Functional Mock-Up Laboratory¶

FUMOLA is a co-simulation framework specifically designed to support the features offered by the FMI specification. FUMOLA is developed on top of the Ptolemy II framework (http://ptolemy.eecs.berkeley.edu/) and the FMI++ library (http://fmipp.sourceforge.net/), mapping Ptolemy II’s functions to the functionality provided by the FMI++ library. Therefore, it provides a flexible platform to investigate the full range of possibilities offered by the FMI specification based on advanced simulation concepts. This allows for implementation of various simulation approaches, including discrete event-based simulations [MW15], simulations of coupled physical systems [WMB+15] and simulations of closed-loop control systems models [WJEP15].

FUMOLA is available at http://fumola.sourceforge.net.

### 6.5.6. WRM (Waveform Relaxation Method) as a Proposition of a Simple Master Algorithm¶

The Waveform Relaxation Method [Lel82][LRSV82] has existed since 1982 and was developed and used to solve large systems of ordinary nonlinear differential equations [IC90], in particular for integrated circuit simulations. The method was adapted to be able to be used as a master algorithm for coupling different black box software components such as FMUs [RRDW15].

The idea is to combine several heterogeneous systems that may have different dynamics, and couple them using an iterative method on the waveforms (Fig. 6.10). Each system is solved in time throughout the considered time domain, and its solution, e.g., the entire waveform, is used as an input of the other systems. The procedure can be done for the whole time domain, or for a sequence of sub-domains. This approach is like a strong coupling, and instead of exchanging simple values at a given time, it exchanges the waveform.

WRM has many advantages. The master algorithm is simple and easy to implement. It can be used to couple different components without having to know the internal dynamics and simulation step sizes. In situations where time exchange data between components is important, such as for a web service, the WRM reduces the computation time by reducing the number of calls of the different sub-models. As the simulation time gets longer, the efficiency of the waveform relaxation method increases [RRDW15].

Limitations and disadvantages include less efficient simulations for models that have events. See the application in [RRDW15].

### 6.5.7. Domus¶

Domus is a building simulation software written in C++. It has an OpenGL-based graphical interface that has been improved to allow importing models from EnergyPlus 8.0 or higher as a FMU for co-simulation 1.0. Domus has also been improved for

1. shading and sunlit area calculation using a pixel counting technique,
2. reading and writing of EnergyPlus IDF files, and
3. co-simulation with ANSYS-CFD.

This last capability can allow for instance the co-simulation for performance assessment of whole-buildings with 3-D ventilated walls combined with indoor and outdoor air flow under heterogeneous surface boundary conditions. Domus is available from http://www.domus.pucpr.br/. See [MOG03][MBZF08] for more information.

### 6.5.8. MasterSim¶

MasterSim is an open-source co-simulation master implementation that supports FMI 1.0 and 2.0.

The simulation master was developed specifically for application in building energy simulation, i.e, interfacing of building simulation models with HVAC system models and control systems, or specialized sub-system models. The master employs several algorithms for obtaining stable, efficient and error controlled solutions. It contains

• different master algorithms/iteration methods, such as non-iterative Gauss-Jacobi, and iterative Gauss-Seidel and Newton methods,
• variable communication step sizes with local error control,
• serialization/deserialization for stop-and-restart of the master.

MasterSim is developed in C++ and runs on Windows, Mac OS X and Linux. Also, the master supports a feature that disables automatic unzipping of FMU archives, which allows for using persistent DLL/shared library files, which is important for FMU developers.

MasterSim is available from http://mastersim.sourceforge.net under a GPL v3.0 license.

## 6.6. Desired FMI Features and Proposal of Evolutions of the Standard¶

While the FMI standard is well-suited for our classes of problems, as with any other standard that covers such a complex use case, there are certain limitations encountered and improvements that the Annex 60 participants would like to see in future versions of FMI. As a result of Annex 60, some changes have been proposed to the standards committee. For this cases, we list below the ticket number of the FMI development site. This section provides an overview of the key challenges encountered while using FMI version 1.0 and 2.0, with actions undertaken to address some of the limitations.

Change of array size during initialization: The size of arrays used for inputs, outputs and state variables is fixed once the FMU is generated. It would be desirable to allow defining array variables as quantities where the array size is being controlled by a parameter given during the instantiation of an FMU. This would allow pre-compiling FMUs in which array sizes vary for different applications, such as for CFD, ray-tracing, or heat conduction through solids and through windows.

For this item, the FMI committee has a working group.

FMU time unit: The FMI standard does not specify the unit of the time passed to the FMUs. This can result in synchronization problems if slaves assume a different unit for time. Thus it would be desirable to extend the standard to specify the unit of the time passed to the FMU slaves, or conversely, state in the specification that time is in seconds, which seems to be the implicit assumption and corresponds to what most, if not all, tools implement. Currently, FMU exporters have to agree on a time unit and specify this in the interface description.

A ticket has been filed on the FMI issue tracker (ticket #307).

Handling of FMU-specific output and log files: While FMI 2.0 provides a path to a read-only resource location, such as for data files to be read by the model, it does not provide a path to a writable location where output and log files shall be written. Knowledge of such a writable location is important, for example, when the same FMU is instantiated several times within a co-simulation scenario. Then, each FMU instance needs to use a different root directory for its written files in order to avoid overwriting each other’s files. The same applies when multiple co-simulation runs are executed in parallel using the same FMU files. Hard-coding writable paths inside the FMU does not work in this situation. Use of the current working directory as basis does not work on the Windows platform, since several Windows API function related to file and directory handling change the working directory. The outcome depends on the order in which the FMUs are instantiated and initialized, and on their internal operation. Therefore, it would be meaningful to pass such a directory, if available on the given platform, during instantiation of the FMU. Without a formal method, FMUs must agree on a specific name of the output directory, and the master algorithm must set this before entering the initialization mode of an FMU.

A ticket has been filed on the FMI issue tracker (ticket #299).

Support for structured variables: FMI 2.0 only defines scalar variables in the ModelVariables subsection of fmiModelDescription at the root-level of the schema file modelDescription.xml. Various domains (e.g. fluid, heat transfer, electrical, magnetic, mechanics) would benefit from supporting structured variables of fixed size, especially one-dimensional arrays, instead of only scalar variables. This would also require new fmi2GetXXX and fmi2SetXXX functions.

For this item, the FMI committee has a working group.

Event handling in co-simulation: In FMI for co-simulation 2.0, an FMU cannot announce to the master algorithm an upper bound for the step it can simulate. Rather, an FMU will have to reject a step size requested by the master if it is too long. [BGL+15] suggests a new function fmiGetMaxStepSize that would allow an FMU to announce how long a step it can take. A similar suggestion is also made by [TCT+16], who propose to add the next event time to a new function fmi21DoStep. Announcing the maximum step size would be useful, for example, if a model knows its next time event and hence can ask the master to step no further than that time point. With the current implementation, a master algorithm may step over this time instant, then get notified by the FMU that it went too far, and then ask the FMUs to rollback and do a smaller step.

This item is in discussion within the FMI committee.

Efficient mechanism for output writing in FMI for model exchange: Currently it is unclear how to handle FMU-specific outputs efficiently in FMI 2.0 for model exchange. For example, in a building simulation FMU, at certain time points, usually hourly or every 15 minutes, a lot of output data needs to be stored in output files. Passing that amount of output data through the FMI interface seems not practical.

The integrator within the master algorithm may use a higher-order integration method with variable time steps, such as CVODE. Therefore, integration steps and output steps in the FMU generally do not match.

Currently the only means for the ModelExchange FMU to identify a suitable time point for writing past outputs is the fmi2CompletedIntegratorStep function. The FMU may than write outputs within the last step at the scheduled time point. However, the FMU does not have information about the higher-order integration method of the integrator. Therefore, backward interpolation will likely give different results compared to those computed by the integrator.

A ticket has been filed on the FMI issue tracker (ticket #326).

Master shall be required to set fixed parameters even if unchanged Currently, when specifying fixed parameters in the modelDescription.xml file, the standard does not require that the master calls fmi2SetXXX functions for such parameters. Most master implementations currently set the parameters, even if the values have not been changed by the user.

In order to ensure consistency between the default parameter values set during the export of the FMU and the values in the modelDescription.xml file, it would be useful to require the master to always set the values during the initialization of the FMU.

A ticket has been filed on the FMI issue tracker (ticket #366).

## 6.7. Best-Practice Recommendations¶

This section summarizes best practices proposed by Annex 60 participants for building or district-level simulations using the FMI standard.

### 6.7.1. Climate Data Export¶

While simulating coupled FMUs, redundant calculations of the same physical part should be avoided because of the risk of inconsistency. Typically, this problem occurs when climate data calculation are performed by different FMUs simultaneously. An example is a system with two FMUs, one for a building model, and one for an HVAC system, which both require outdoor conditions.

As climate data only depend on time, using a common FMU for climate data will not create cyclic dependencies among FMUs.

Since there are different possibilities for defining climate parameters (units, naming conventions, sun coordinate system, etc.) standardizing an interface for climate data would be beneficial.

### 6.7.2. FMI Interfaces for Room and HVAC Systems¶

Different variables could be exposed at the interface of rooms and HVAC systems. In order to make different FMUs compatible, an FMI package has been added to the Annex60 library which allows for exporting HVAC models, HVAC systems, and thermal zones as FMUs. This package contains connectors that can be exposed to retrieve and to output HVAC system variables. The package also contains FMI adaptors, which have been added to facilitate the export of HVAC systems. See http://www.iea-annex60.org/releases/modelica/1.0.0/help/Annex60_Fluid_FMI.html for documentation. The rationale for the selection of variables that are used as inputs and outputs of the HVAC FMU are discussed in [WFN15]. Fig. 6.11 shows a model of a heater with the FMI interfaces. The instances bou* convert between causal input and output signals and the acausal fluid ports.

## 6.8. Conclusions¶

This chapter demonstrates that having a standard for exchanging models between different simulators and for linking simulators during run-time is an important topic for building and district energy system simulation. As building and district energy simulation typically involve large models and long simulation periods, having efficient master algorithms is important. The participants of Activity 1.2 demonstrated that FMI is useful for various applications. They also demonstrated the capability of tools to export, import, and co-simulate models encapsulated as FMUs. They showed that the FMI approach is suited for solving the multi-physics, multi-component systems encountered in the simulation of buildings, and they contributed to proposals for further improving the FMI standard. Simulation coupling with open-source standards is potentially a key for tackling the scalability issues that will be encountered for district-level simulations. This is one of the big challenges that building and district energy simulations will encounter in the years to come.

 [1] To allow larger communication time steps, the FMI standard also allows for providing time derivatives of the continuous real inputs.


text:
Competitions

# Diagonal

The number of diagonals of an n-gon is not less than N. What is the minimum possible value of n?

#### Input

Contains less than 1001 lines. Each line contains a positive integer N (N1015) that indicates the minimum possible number of diagonals. Input is terminated by a line with one 0 that should not be processed.

#### Output

For each test case produce one line that contains serial number and the minimum possible value for n (number of sides).

Time limit 1 second
Memory limit 128 MiB
Input example #1
10
100
1000
0

Output example #1
Case 1: 7
Case 2: 16
Case 3: 47

format: plain


text:
# If sin36=a, express each of the following in terms of a

• September 3rd 2012, 08:46 AM
VegetaZA
If sin36=a, express each of the following in terms of a
This is the first time that I am doing these sections in trig so I need detailed answers. If possible, please do the answers first and then give the explanations. Please try and answer as many questions possible.
http://s10.postimage.org/vzu7cpftl/scan0001.jpg

I need these answers ASAP so that I can study for a test.

• September 3rd 2012, 08:47 AM
Prove It
Re: If sin36=a, express each of the following in terms of a
You're not going to get full solutions here. Show what you have tried, then we can give you some more guidance.
• September 3rd 2012, 08:49 AM
VegetaZA
Re: If sin36=a, express each of the following in terms of a
I would love to try it but I've never done this before. I've only done basic trig and that is why I'm asking for detailed answers.
• September 3rd 2012, 11:48 AM
HallsofIvy
Re: If sin36=a, express each of the following in terms of a
All of these can be done using basic trig. And that is how you do mathematics- you try something and if it doesn't work, try something else. In problem 1, do you notice that every one of those angles can be written as 36 plus or minus some multiple of 90? Surely in "basic trig" you learned that $sin^2(x)+ cos^2(x)= 1$. One of these uses that directly!
• September 3rd 2012, 09:09 PM
VegetaZA
Re: If sin36=a, express each of the following in terms of a
I've worked out some of them. Will post pics of it later today:)


text:
Question

# Write the linear factorization and list all the zeros of p(x)=x^{4}+x^{3}-8x^{2}-2x+12.

Polynomial factorization
Write the linear factorization and list all the zeros of $$p(x)=x^{4}+x^{3}-8x^{2}-2x+12$$.

2021-05-09
Step 1
$$p(x)=x^{4}+x^{3}-8x^{2}-2x+12$$
$$\Rightarrow p(x)=x^{3}(x-2)+3x^{2}(x-2)-2x(x-2)-6(x-2)$$
$$\Rightarrow p(x)=(x-2)(x^{3}+3x^{2}-2x-6)$$
$$\Rightarrow p(x)=(x-2)[x^{2}(x+3)-2(x+3)]$$
$$\Rightarrow p(x)=(x-2)(x+3)(x^{2}-2)$$
$$\Rightarrow p(x)=(x-2)(x+3)(x+\sqrt{2})(x-\sqrt{2})$$
Step 2
linear factorization of p(x).
$$p(x)=(x-2)(x+3)(x+\sqrt{2})(x-\sqrt{2})$$
Zeros of p(x):
$$2,-3,\sqrt{2},-\sqrt{2}$$.


text:
A given fraction and the fraction obtained by multiplying (or dividing) both its numerator and denominator by the same non-zero number are called equivalent fractions.

$\frac{1}{2}$ , $\frac{2}{4}$ , $\frac{3}{6}$ are examples of equivalent fractions.

Equivalent fractions are found by multiplying both the numerator and the denominator by the same number. Equivalent fractions can also be found by dividing both the numerator and the denominator by the same number.

## What is an Equivalent Fraction?

Look at the representation of a few fractions:

The shaded areas in these figures represent the fractions, $\frac{1}{2}$ , $\frac{2}{4}$ , $\frac{3}{6}$ respectively. If we place one diagram over the other, they are found to be equal. That is, the fractions representing these shaded areas are equal. Such fractions are called as equivalent fractions.

### Facts about Equivalent Fractions:

If two fractions are equivalent, then the product of the numerator of the first and the denominator of the second is equal to the product of the numerator of second and the denominator of the first fraction.

In other words, if $\frac{a}{b}$ = $\frac{c}{d}$ , then we can say that ad = bc.

### Like Fractions

 Equivalence Relations Equivalent Decimals What are Like Fractions? What is a Fraction? Improper Fraction to Mixed Fraction Add Fraction Complex Fraction Derivative of a Fraction Derivative of Fractions Divide Fractions Fraction Exponents How do I Reduce a Fraction
 Calculator for Equivalent Fractions Equivalent Ratios Calculator A Fraction Calculator


text:
# Contents of /trunk/doc/user/pyvisi.tex

Revision 1211 - (show annotations)
Wed Jul 4 05:16:46 2007 UTC (12 years, 7 months ago) by jongui
File MIME type: application/x-tex
File size: 50393 byte(s)
- Fixed some minor bugs.
- Added a new feature called 'MapOnScalarClipWithRotation' that clips a two-dimensional data with a scalar value and subsequently rotating it to create a three-dimensional effect.
- Corresponding examples, test cases and documentation of the new module have also been added.


text:
@inproceedings{Honda1993TypesFD,
author={Kohei Honda},
booktitle={CONCUR},
year={1993}
}
• Kohei Honda
• Published in CONCUR 23 August 1993
• Computer Science
We formulate a typed formalism for concurrency where types denote freely composable structure of dyadic interaction in the symmetric scheme. The resulting calculus is a typed reconstruction of name passing process calculi. Systems with both the explicit and implicit typing disciplines, where types form a simple hierarchy of types, are presented, which are proved to be in accordance with each other. A typed variant of bisimilarity is formulated and it is shown that typed β-equality has a clean…
429 Citations
Composing processes
It is proved that the class of typable operations in the underlying partial algebras is completely characterised by a certain modularity principle in process composition, which gives the basic understanding on the nature of the type disciplines representable in the proposed construction.
Higher-Order Processes, Functions, and Sessions: A Monadic Integration
• Computer Science
ESOP
• 2013
This paper uniformly integrating a Curry-Howard interpretation of linear sequent calculus as session-typed processes in a functional language via a linear contextual monad that isolates session-based concurrency through a logical foundation for higher-order session typed processes.
Dependent Communication in Type Theory
We present an expressive type system for a language extending the usual λ-calculus with concurrency primitives from the π-calculus. This language uses dependent types as found in type theory,
Session types in concurrent calculi : higher-order processes and objects
This dissertation investigates different formalisms, in the form of programming language calculi, that are aimed at providing a theoretical foundation for structured concurrent programming based on session types, and presents contributions to the theory of sessions, distilled into two families of programming calculi.
A Dependently Typed Linear π-Calculus in Agda
• Computer Science
PPDP
• 2020
This work proposes a variant of the linear π-calculus whose type structure encompasses virtually all dependent session types using just two type constructors: linear channel types and linear dependent pairs.
Strong normalisation in the pi -calculus
• Computer Science, Mathematics
Inf. Comput.
• 2004
This work introduces a typed π-calculus where strong normalisation is ensured by typability, and is one of the first steps to extend theories and proof methods for strong normalisability to the context of name-passing processes.
A process-calculus approach to typed concurrent objects
This work brings into the name-passing paradigm (not restricted to the calculus presented, but encompassing the -calculus and the calculus) the notions of types and type assignment, thus opening the possibility to explore, in the setting of name-Passing calculi, the wide body of results on type systems for -calculi.
π with leftovers: a mechanisation in Agda
• Computer Science
FORTE
• 2021
This work presents the first full mechanisation in Agda of a {\pi}-calculus with linear, graded and shared types, all under the same unified framework, and shows that the type system is stable under substitution and prove subject reduction.
Intersections and Unions of Session Types
• Computer Science
ITRS
• 2016
It is observed that the system can represent internal and external choice by intersection and union, respectively, which was previously suggested by Padovani for a different language of session types motivated by operational rather than logical concerns.
Predicative Polymorphism in Pi-Calculus
The new presentation introduces an operator to express recursion, and an ML-style let-constructor allowing to associate an agent to an agent-variable, and use the latter several times in a program.

References

SHOWING 1-10 OF 30 REFERENCES
Typing and subtyping for mobile processes
• Computer Science
[1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science
• 1993
The authors define the syntax, typing, subtyping, and operational semantics of their calculus, prove that the typing rules are sound, apply the system to Milner's lambda -calculus encodings, and sketch extensions to higher-order process calculi and polymorphic typing.
Type Systems for Programming Languages
• John C. Mitchell
• Mathematics, Computer Science
Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics
• 1990
The technique of logical relations is used to prove a semantic completeness theorem and Church–Rosser and strong normalization properties of reduction and encompass basic model-theoretic constructions such as quotients.
Computational Interpretations of Linear Logic
• S. Abramsky
• Mathematics, Computer Science
Theor. Comput. Sci.
• 1993
Girard's linear logic is studied from the point of view of giving a concrete computational interpretation of the logic, based on the Curry—Howard isomorphism, which opens up a promising new approach to the parallel implementation of functional programming languages.
A Theory of Type Polymorphism in Programming
• R. Milner
• Computer Science
J. Comput. Syst. Sci.
• 1978
This work presents a formal type discipline for polymorphic procedures in the context of a simple programming language, and a compile time type-checking algorithm w which enforces the discipline.
A Calculus of Mobile Processes, Part I
We present the -calculus, a calculus of communicating systems in which one can naturally express processes which have changing structure. Not only may the component agents of a system be arbitrarily
An Object Calculus for Asynchronous Communication
• Computer Science
ECOOP
• 1991
This paper shows basic construction of the formal system along with several illustrative examples of the communication primitive, which results in a consistent reduction of Milner's calculus, while retaining the same expressive power.
Interaction nets
A new kind of programming language, with the following features: a simple graph rewriting semantics, a complete symmetry between constructors and destructors, and a type discipline for deterministic and deadlock-free (microscopic) parallelism.
A calculus of mobile processes, II
• Computer Science
• 1992
The a-calculus is presented, a calculus of communicating systems in which one can naturally express processes which have changing structure, including the algebraic theory of strong bisimilarity and strong equivalence, including a new notion of equivalence indexed by distinctions.


text:
spacing in math mode

# LaTeX spacing in math mode

StartLaTeX faqLaTeX topicsLaTeX course
< text in math mode     > side by side tables

## spacing in math mode

Because blanks were ignored within math mode, they have to be set by a special command:$x\;y$
more commands for spacing in math mode
 $x\!y$ $xy$ $x y$ xy $x\,y$ $x\:y$ $x\;y$ $x\quad y$ $x\qquad y$


text:
This problem was first posed by James Whittaker in 1966 (you can ch...
In mathematical terms the problem can be re-written as: Let $s(\... When one or two of the climbers hit a critical point (peak or valle... The sum of all the degrees of a graph$D_{Total}\$ is composed by th...
In this paper we prove that the parallel climbers problem has a sol...


text:
• Save

# TOP 100 Logical Reasoning Questions and Answers

Last year 17.5K Views

Logical reasoning part is that part which you have to solve questions logically. So here in this blog, giving you are top 100 logical reasoning questions and answers for better performance. Because some students ignores some questions or chapter sometimes and by this blog, you can practice important logical questions and answers which asked frequently in the competitive exams.

So, you should practice these questions to obtain good marks in the competitive exams.

## Important 100 Logical Questions with Answers

Direction: Two statements are given & then two conclusions – 1 & 2 are given. You have to consider the statement as true though it seems to be different from the actual facts. Then give your answer regarding the given statement that which of the conclusion/s is/are followed by it properly.

Q.1. Statement:

1. All the well-graced people are happy.

2. Any unhappy person is not the well-graced.

Conclusion:

1. Happiness & well-graciousness are correlated

2. Unhappy person is not well-graced

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   D

Q.2. Statement:

1. One of the reasons for the failure in examinations is irregularity.

2. Some regular students fail in the examinations.

Conclusion:

1. The students getting failure are regular.

2. All the succeed students are not regular.

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   C

Q.3. Statement:

1. Sachin is a good cricketer

2. Sachin’s sister sings well.

Conclusion:

1.Sachin & his sister are good cricketers.

2. Sachin & his sister are talented.

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   B

Q.4. Statement:

1. Soldiers serve for the country.

2. Students are not soldiers.

Conclusion:

1. Students do not serve for their country.

2. Some students serve for their county.

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   C

Direction: A statement is given & then two conclusions – 1 & 2 are given. You have to consider the statement as true though it seems to be different form the actual facts. Then give your answer regarding the given statement that which of the conclusions/is/ are followed by it Properly.

Q.5. Statement:

Mother crafts is an art. Young parents needs the training for methods of mother craft.

Conclusion:

1. Now a day the young parents do not have any knowledge about mother craft.

2. Young couples will be better parents because of the training.

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   A

Q.6. Statement:

The happiness got form outer sources is momentary, the everlasting happiness comes from our inside.

Conclusion:

1. Any person cannot experience the outer happiness.

2. The happiness from cinema is not everlasting.

(A) Only 1 is followed

(B) Only 2 is followed

(C) Neither 1 nor 2 is followed

(D) 1 & 2 – both are followed

Ans .   B

Direction: (7-11): In these question, @, #, $, * & % symbols are used for different meaning as follows: ‘A @ B’ means A is not less than B. ‘A # B’ means A is neither less than nor equal to B. ‘A$ B’ means A is neither less than nor greater than B.

‘A * B’ means A is not greater than B.

‘A % B’ means A is neither greater than nor equal to B.

Considering all the statement in each question true, find that which of the following two conclusion – I & II is definitely true.

Give the answer (A) if only conclusion I is true.

Give the answer (B) if only conclusion II is true.

Give the answer (C) if either conclusion I or conclusion II is true.

Give the answer (D) if neither conclusion I nor conclusion II is true.

Give the answer (E) if conclusion I & conclusion II – both are true.

Q.7. Statement: L * P, P % V, V # D

Conclusion:  I. L * V

II. L $D Ans . D Q.8. Statement: V * W, W$ H, H @ I

Conclusion:  I.  V * I

II. I * W

Ans .  B

Q.9. Statement: N @ W, W # H, H % T

Conclusion: I. H % N

II. T # W

Ans .  A

Q.10. Statement: F # R, H % R, L * H

Conclusion: I. F # L

II. R @ L

Ans .  A

Without any hesitation, you can ask me anything in the comment section related to top 100 logical reasoning questions. Please visit on the next page for more preparation.


text:
Ill posed Cauchy problems for ideal gas equations and their regularization
Journées équations aux dérivées partielles, (1987), article no. 19, 17 p.
@article{JEDP_1987____A19_0,
author = {Maslov, V. P.},
title = {Ill posed Cauchy problems for ideal gas equations and their regularization},
journal = {Journ\'ees \'equations aux d\'eriv\'ees partielles},
publisher = {Ecole polytechnique},
year = {1987},
zbl = {0641.76068},
mrnumber = {920014},
language = {en},
url = {http://www.numdam.org/item/JEDP_1987____A19_0}
}

Maslov, V. P. Ill posed Cauchy problems for ideal gas equations and their regularization. Journées équations aux dérivées partielles,  (1987), article  no. 19, 17 p. http://www.numdam.org/item/JEDP_1987____A19_0/


text:
# For problems 1 through 11, use the following sets. The set U is the universal set.0- -32, - 8, -2, - 3, 1, 4, 16, 64)N-1,2,4,8)U= {-32,-8,-2, .. 1, 2, 100-, 8. 1004. 10003, 64)S-2245, 1000,, B16)1. Write set B in roster notation.2. Write set O in set-builder notation3. Write the number of subsets of N in binary4. Write the number of proper subsets of U in hexidecimal.5. Convert each element of S to base-ten (decimal)6. How many two-way intersections of the sets B. O. N u. and S exist? (e.g. Nno, ons, etc)7. If -47

Question

I only need the explanation of number 8. I do not know how to do it. Thanks

Step 1

As per norms, the subparts for question 8 are answered.To analyze the given relation f.

Step 2

f , being a relation from O to N is a subset of O x N (the cartesian product). As f is defined as square root, the elements -32,-8,-2 and -1/2 are n...

### Want to see the full answer?

See Solution

#### Want to see this answer and more?

Our solutions are written by experts, many with advanced degrees, and available 24/7

See Solution
Tagged in


text:
# ↳ Covid19

## An interview with Mark Blyth

Mark Blyth is William R. Rhodes Professor of International Political Economy at Brown University and a Faculty Fellow at Brown’s Watson Institute for International Studies. His research examines how the interests of states and economic actors shape ideological consensus and institutional development at the global scale. He is the author and editor of many books, including Great Transformations: Economic Ideas and Institutional Change in the Twentieth Century (2002), The Future of the Euro (2015), and Austerity: The History of a Dangerous Idea (2013).

His latest book is Angrynomics, in which he and co-author Eric Lonergan argue that the rising tide of anger dominating global politics has its roots in decades of macroeconomic policymaking. Earlier in the pandemic, I spoke with Blyth about the economics of the Covid-19 crisis, the various approaches that governments and central banks across the globe have followed in order to tame it, and what an alternative program for the global economy might look like.

## PUBLIC HEALTH FEDERALISM

Catastrophic deficiencies in the federal response to the Covid-19 pandemic have led to renewed discussion over federalism and its discontents. The divergence among state responses to the crisis in the absence of federal guidance has produced analyses of Trump’s unique, “narrow” sense of federalism, pronouncements of “a new era of federalism,” and hopes for a solidarity-minded “civic federalism.”

In a 1997 article, health law professor JAMES G. HODGE JR. analyzes the impact of state-centric “new federalism” jurisprudence on the government’s ability to realize public health goals. Hodge places new federalism in the context of decades of increasing intrusion by the federal government on states’ power over public health policy:

"The impact of new federalism on the field of public health law is seen in the history of public health regulation. The metamorphosis of public health regulation from purely local to predominantly national means resulted from increased federal presence in the field corresponding to a deemphasis on traditional federalism. It is an inescapable conclusion that an increased federal presence shifted public health goals. National public health priorities dominate local ones. New federalism restrains the federal intrusion on state public health powers by requiring Congress to operate within the constraints of the political process. As a result, state police powers exercised in the interest of public health are strengthened emphatically by the political process confining federal authority to enter the field."

Full paper available here.

• In an article published this April, Hodge reassesses federal vs. state public health powers in light of disparate responses to the pandemic: "Americans are left wondering, 'which level of government is actually in charge here?' In the face of a pandemic like Covid-19, the answer under principles of federalism is increasingly clear: neither." Link.
• "American federalism—with its fissures and fractures—haunts the state of emergency." A March post from Phillip Rocco. Link. (See also Rocco's recent post on fiscal federalism in Notes on the Crises.) Along similar lines: Rocco, Daniel Béland, and Alex Waddan on the fiscal barriers to pandemic response. Link. And Nicole Huberfeld, Sarah H. Gordon, and David K. Jones argues that the pandemic has magnified the state-level inequities fostered by federalism. Link.
• For another view on the relationship between federalism and public health: A 2014 paper by Adam Varvel on the West Nile outbreak of 1999. Link. See also: A post-SARS policy brief on the impact of federalism on international health regulations. Link.

## What the pandemic teaches us about poverty measurements

Since the onset of the Covid-19 pandemic in the United States, more than 40 million people have applied for unemployment benefits. In April, unemployment spiked to nearly 20 percent, almost double the rate observed at the peak of the Great Recession. To blunt the financial blow, Congress passed the CARES Act, a package that included, among many other things, around $500 billion in income transfers for the U.S. population. With my colleagues at Columbia University’s Center on Poverty & Social Policy, I have worked to understand how the CARES Act might affect annual poverty rates in the U.S. Our findings took us by surprise: despite the rapid rise in unemployment, we find that the CARES Act’s two major income transfers—the Recovery Rebates (one-time stimulus payment) and expanded unemployment benefits—have potential to return projected poverty rates to pre-crisis levels if access to the benefits is adequate. Jason DeParle of The New York Times neatly brings life to the findings here, while our full report can be found at the Center’s website. The report also details the many important shortcomings of the CARES Act, such as its exclusion of undocumented immigrants, the difficulties that families are facing in accessing the benefits, and the upcoming expiration of the top-up to unemployment benefits. ### May 19th, 2020 ## Plate Study ## STABLE SHOCK ### Remittances across contexts Among the many corona-induced shocks rippling through the global economy is the crash in remittance payments to developing countries. The World Bank predicts that remittance flows will fall 20% this year—a decline of$100b—largely as a result of shutdowns and wage losses in the global north. The politics of remittances are complex: the scholarly literature both touts the positive development effects of countercyclical cash inflows, and questions the effects of a system that supports consumption at the expense of longer-term economic development.

In a fascinating study on remittances from GCC countries—where migrant workers tend to have few rights while making up a large share of the population—FAISAL Z. AHMED looks at the political effects of remittance economies.

"Using duration models of government turnover for a sample of 97 countries between 1975 and 2004, this article demonstrates that the combination of aid and remittance inflows can empower governments in autocracies to survive longer. The link between the effects of foreign aid and remittances on government survival hinges on the fact that these inflows of money constitute forms of unearned foreign income that a government can potentially exploit for nefarious purposes. This is achieved via two channels. In the first, governments direct some foreign aid to finance patronage goods (income effect). In the second, governments respond to shocks in unearned and largely untaxable household income (i.e., remittances) by diverting expenditures from the provision of welfare goods in favor of patronage goods (substitution effect). My findings suggest that domestic political institutions (and the incentives they generate for governments) mediate the impact of aid and remittance inflows on the quality of governance and the endurance of governments in autocracies."

• A 2019 analysis from the Financial Times provides an excellent overview of remittances to emerging market economies. Link. Part of a FT series on remittances, including case studies on Zimbabwe and Nepal, and reporting on the nations attempts to issue "diaspora bonds" to attract the earnings of expatriate workers. Link to the series.
• A paper by Muhammed Tariq Majeed looks at the effects of remittances on poverty across 65 countries from 1970-2008. Link. Relatedly, a 2015 paper by Phanindra Wunnava et al looks at the impact of financial liberalization on remittances across 84 countries from 1986-2005, and finds mixed results: increased economic freedom in the financial sector has a positive impact, while improved robustness of financial markets has a negative and lagged effect. Link. h/t Alison Oh
• A 2011 paper by Rui Esteves and David Khoudour-Castéras examines remittances and capital flows in the European periphery from 1870-1913. Link.

## GREATER SHAPE

### Public opinion and policymaking

Covid is changing popular attitudes towards the public sector, prompting many commentators to anticipate a new period of welfare expansion. Others are more skeptical, noting that public opinion undergoes rapid fluctuations, which rarely resolve into a new equilibrium.

Like its forebear in debates over the 1981 Meltzer-Richards model, the present discussion assumes a strong relationship between public opinion and policymaking. A 2012 book by political scientist MARTIN GILENS demonstrates the flaws underlying this assumption.

From the book:

"Democracy is commonly understood to entail a substantial degree of political equality. This ideal of political equality is perhaps impossible to fully achieve in the face of economic inequality—in every democracy citizens with greater resources are better able to shape government policy. But the degree of political inequality in a society tells us much about the quality of the society’s democracy. I aim to document and explain patterns of representation in the United States over the past few decades by examining the relationship between the policy preferences expressed by the American public and the policies adopted by decision makers in Washington. To do so I have assembled a dataset of survey questions reflecting the policy preferences of hundreds of thousands of Americans at different income levels on all sorts of government policies—from raising the minimum wage, to restricting abortions, to sending U.S. troops to Bosnia.

When preferences across income groups diverged, only the most affluent appeared to influence policy outcomes. Representational inequality was spread widely across policy domains, with a strong tilt toward high-income Americans on economic issues, foreign policy, and moral/religious issues, and only modestly greater equality of responsiveness to the middle class and the poor in the social welfare domain. Even this partial exception to the dominance of the affluent was accounted for by the fortuitous confluence of preferences between middle-class citizens and powerful interest groups on issues like health care, education, and Social Security. Yet the importance of political conditions in shaping responsiveness means that our political destiny is not predetermined. The obstacles to enhancing representational equality in America are considerable, but the costs of not doing so are considerable as well."

• Jacob Hacker and Paul Pierson's much-cited Winner Take All Politics outlines the mechanisms of policy influence in the US. Link.
• A new paper by Matias López et. al examine the economic and social factors which shape elite attitudes towards redistribution in Brazil. Link. h/t Paul
• "In 1893, the historian Frederick Jackson Turner famously argued that the American frontier fostered individualism. We investigate this thesis by tracking the frontier between 1790–1890 and constructing a novel, county-level measure of total frontier experience (TFE). Long after the closing of the frontier, counties with greater TFE exhibit more pervasive individualism and opposition to redistribution." Samuel Bazzi, Martin Fiszbein, and Mesay Gebresilasse on the historical roots public opinion. Link.

## Security for the People

### Ethics in mitigation

Following the comparative success of South Korea and Singapore to flatten the Covid-19 curve, governments around the world have been discussing the merits and feasibility of tech-aided contact tracing systems. (Whether these comparative public health successes are actually attributable to such systems remains a point of debate.) In the US context, app-based tracing proposals have been floated by various think tanks, and Apple and Google have released protocols for their design.

Privacy concerns are paramount, as are questions of efficacy and the opportunity costs of new mitigation tools. In a white paper last month, Danielle Allen, Lucas Stanczyk, Glenn Cohen, Carmel Shachar, Rajiv Sethi, Glen Weyl, and Rosa Brooks examined the ethical and legal bases of pandemic mitigation.

From the paper:

"We are currently in the initial stage of facing the spread of an epidemic, with clear emergency needs to secure our health system while seeking to minimize lives lost and ensure that all patients, including the dying, are treated with dignity. We have to fend off a near-term catastrophe, and in that regard we are in our 'triage' moment. We are currently making triage decisions across all sectors of society.

Securing our health infrastructure and minimizing loss of life requires changing the trajectory of transmission through screening, testing, contact tracing, mobility restrictions, and social distancing. Whereas contact tracing and individualized quarantine and isolation suffice in non-pandemic circumstances, community quarantine and isolation become necessary under pandemic conditions in order to address the emergency. Here the challenging questions are to create the right package of temporarily adjusted norms, regulations, and laws around rights of mobility and association, and to determine whether the relevant packages of norms, regulations, and laws are best."

The authors propose guidelines for decision procedures that promote mitigation without violating civil liberties, justice, democratic institutions, or the "material supports of society." Link to the paper. h/t David Grant

• An evolving list of projects using personal data for Covid-19 response. Link.
• From a 2019 paper on the efficacy of contact tracing and epi models: "A major concern identified in future epidemics is whether public health administrators can collect all the required data for building epidemiological models in a short period of time during the early phase of an outbreak." Link. A 2018 paper on contact tracing's role in the 2014-2015 Ebola outbreak in Liberia. Link.
• Previously shared in this newsletter, a technical paper for the Decentralized Privacy-Preserving Proximity Tracing (DP-3T) protocol. The tweet-length summary from researcher Michael Veale: "Health authorities learn nothing about users. Users learn nothing about other users. Users learn if they were too close to others who tested positive. Governments learn nothing about users. No-one is coerced: everything based on genuine, voluntary consent." Link to the paper. (And link to a comic strip explanation of how it works.)
• An excellent blog post from Ross Anderson at Cambridge's Department of Computer Science and Technology on contact tracing in the real world. Link. See also "Apps Gone Rogue: Maintaining Personal Privacy in an Epidemic." Link.

## The underlying problems in the US economy

Today’s Bureau of Labor Statistics (BLS) report hardly registers the cataclysm in the US job market. The sharp 0.9 percent uptick in unemployment—itself newsworthy—only grasps the very beginnings of the shutdown of the American economy. Since the BLS surveys were conducted in the week of March 12, 10 million people have filed for jobless benefits. Only when the April numbers are released at the beginning of next month will we begin to get a fuller statistical picture of the magnitude of the Covid-19 crash. Unemployment rates are expected to rise to 20 percent or more. Given the 10-year-long, bull run of the stock market, one might imagine that the US economy was in good shape before that crash began, and that the labor market will therefore bounce back from the novel coronavirus’s punch once the public health crisis ends. However, the opposite is true: the fundamentals of the US economy were already incredibly weak. They have been for some time. After a decade of slow economic expansion, the US labor market was barely beginning to recover from the last crisis in 2008. If the past is any guide to the future, it will likely take even longer to recover from this one. We are only starting to get a sense of the true extent of this disaster from the perspective of American workers.

## The shape of the Covid-19 recession

It is hard to see how the United States can avoid a recession. Unemployment insurance claims have already surged, and this week's numbers look to be in the millions. All indications point to one of the fastest plunges of GDP in US history. Facing this, we may want to turn to previous American recessions to think about our immediate future. But the dynamics of this recession will be different in at least one major way from the recessions of recent memory: services. In most recessions, services are basically acyclical—they just don't move up and down with the booms and busts of the economy. The exception here is the Great Depression (see Figure 1 below), but there the decline in investment is much more severe, as is the upward swing in the recovery. Services, it seems, just don't fall that much—even in the Depression.


text:
2019
Том 71
№ 8

# Kapustyan O. A.

Articles: 3
Article (Ukrainian)

### Approximate stabilization for a nonlinear parabolic boundary-value problem

Ukr. Mat. Zh. - 2011. - 63, № 5. - pp. 654-661

For a problem of optimal stabilization of solutions of a nonlinear parabolic boundary-value problem with small parameter of a nonlinear summand, we justify the form of approximate regulator on the basis of the formula of optimal synthesis of the corresponding linear quadratic problem.

Article (Ukrainian)

### Approximate Averaged Synthesis of the Problem of Optimal Control for a Parabolic Equation

Ukr. Mat. Zh. - 2004. - 56, № 10. - pp. 1384–1394

For a problem of optimal control for a parabolic equation, in the case of bounded control, we construct and justify an approximate averaged control in the form of feedback.

Brief Communications (Ukrainian)

### Approximate Synthesis of Optimal Bounded Control for a Parabolic Boundary-Value Problem

Ukr. Mat. Zh. - 2002. - 54, № 12. - pp. 1704-1709

We consider the approximate optimal control based on the principle of feedback relation (synthesis) for a parabolic boundary-value problem. We represent the feedback operator as Fourier series in the eigenfunctions of the Laplace operator, which does not enable us to use these results in practice. In view of this fact, we justify the convergence of approximate controls, switching points, and values of the quality criterion to the exact values of the corresponding variables.


text:
# Using a 555 Integrated Circuit

I posted about the 74HC74 flip-flop on Saturday. For the same project I’m going to use that IC for, I’ll probably use a 555 timer. It’s often referred to as one of the most useful ICs you can get. I’ve never used the 555 either, so I wired up some simple demos using it. In order to show two common timing uses, I’ve created similar circuits each triggered by the same power source and button.

The circuit on the left shows a delay off timer and the one on the right shows a delay on timer. Notice when power is connected (or the button is used as a reset) that the red LED turns on right away and turns off after a few seconds. Just the opposite, the white LED is off when the timer is reset and turns on after a few seconds.

The length of the delays is determined by the capacitor and resistor used with the 555. I’m using an Adafruit Feather to provide 3.3 volts to the circuits with a 22 μF capacitor and 100 K ohm resistor. Using the capacitor charge time formula to multiply the capacitance (farads) by the resistance (ohms), it’s easy to get the time.

$t = RC$

$t = 100000 * 0.000022$

Comes out to 2.2 seconds. To change the time delay all you have to do is use a different capacitor and/or resistor.

Here is a simplified wiring setup because it’s hard to see how everything is connected in the video.

Also check out Combining 74HC74 & 555 Integrated Circuits.


text:
# Fundumental confusion in the interpretation of probability in quantum mechanics

In quantum mechanics we describe a state not yet measured by $|\psi\rangle=c_1|\phi_1\rangle+c_2|\phi_2\rangle+c_3|\phi_3\rangle+\dots$ where $\langle\phi_m|\phi_n\rangle=\delta_{mn}$ and $|c_n|^2$ is probability that we get the state $|\phi_n\rangle$ when measured. But at the same time the quantities like $\langle\phi_n|x\rangle\langle x|\phi_n\rangle$ i.e. $|\phi_n^*(x)\phi_n(x)|$ represented in some '$x$' representation are defined as probability density functions. Isn't this quantity called probability density function always equal to unity as $\langle \phi_m|\phi_n\rangle=\delta_{mn}$ ?

The states $|\phi_m\rangle$ can be expressed as wave functions, as follows $$\langle x|\phi_m\rangle = \phi_m(x) .$$ The probability density function for this state would then be $$|\phi_m(x)|^2 = |\langle x|\phi_m\rangle|^2 = \langle\phi_m |x\rangle \langle x|\phi_m\rangle .$$ The probability density function is not equal to one. It is a function of $x$. However, it integrates to one (as all probability density functions should): $$\int |\phi_m(x)|^2 dx = \int \langle\phi_m |x\rangle \langle x|\phi_m\rangle dx = \langle\phi_m |\phi_m\rangle = 1 .$$
You need to integrate over some region of space. If you integrate from -$\infty$ to $\infty$ then yes the probability density is unity: the particle is indeed somewhere. You'll get a finite probability if your integral has finite bounds.
For a orthonormal basis $e$ (in your case, $e$ is position $x$), we have the outer product: $$\int \lvert e\rangle\langle e\rvert d e = \hat{I}$$ Thus we have: $$\langle\psi\lvert\phi\rangle = \langle\psi\rvert\hat{I}\lvert\phi\rangle =\int\langle\psi|e\rangle\langle e\rvert\phi\rangle\, \mathrm{d}e$$ The probability distribution function $\rho$ has the form:$$\int\rho(x)\,\mathrm{d}x$$ And we call $\langle\psi\lvert e\rangle\langle e\rvert\phi\rangle$ as a probability distribution function.


text:
# [OS X TeX] change header tableofcontents

Gary L. Gray gray at engr.psu.edu
Wed Nov 30 06:46:25 CET 2005

On Nov 30, 2005, at 12:40 AM, gertlist at mac.com wrote:

> hi all,
> the tableofcontents that is generated in my document has the header
> "Contents". Is there a way to change this word "Contents" in the

I think the following should do it: