Unit 7-gear trains, Kinematics of machines of VTU Syllabus prepared by Hareesha N Gowda, Asst. Prof, Dayananda Sagar College of Engg, Blore. Please write to hareeshang@gmail.com for suggestions and criticisms.
Unit 7-gear trains, Kinematics of machines of VTU Syllabus prepared by Hareesha N Gowda, Asst. Prof, Dayananda Sagar College of Engg, Blore. Please write to hareeshang@gmail.com for suggestions and criticisms.
Mobileye’s SeeQ® offers a compact and powerful processing platform for computationally intensive real time visual recognition and scene interpretation applications. The SeeQ® core processing unit includes the EyeQ™ - Mobileye’s powerful vision system on a chip, a High Dynamic Range CMOS image sensor, Flash and SDRAM memories.
The aim of this paper is to show the possibilities offered by Scilab/Xcos to model and simulate aeraulic and HVAC systems. In particular we develop a new Xcos module combined with the use of Modelica language to show how aeraulic systems can be modeled and studied. In this paper we construct a reduced library composed by few elements: hoods, pipes and ideal junctions. The library can be easily extended to obtain a more complete toolbox. The developed library is tested on a simple aeraulic circuit.
The purpose of this tutorial is to show that Scilab can be considered as a powerful data mining tool, able to perform the widest possible range of important data mining tasks.
Modeling an ODE: 3 different approaches - Part 1Scilab
In this tutorial we show how to model a physical system described by ODE using Scilab standard programming language. The same model solution is also described in Xcos and Xcos + Modelica in two other tutorials.
Modeling an ODE: 3 different approaches - Part 2Scilab
In this tutorial we show how to model a physical system described by ODE using Xcos environment. The same model solution is also described in Scilab and Xcos + Modelica in two other tutorials.
In this Scilab tutorial, we introduce readers to the Control System Toolbox that is available in Scilab/Xcos and known as CACSD. This first tutorial is dedicated to "Linear Time Invariant" (LTI) systems and their representations in Scilab.
Customizing Xcos with new Blocks and PaletteScilab
In this tutorial, we show how to create and customize Xcos blocks and palettes. Moreover, we use the "Xcos toolbox skeleton" for a better result. The LHY model in Xcos scheme (already developed in other tutorials) is used as a starting point.
Mobileye’s SeeQ® offers a compact and powerful processing platform for computationally intensive real time visual recognition and scene interpretation applications. The SeeQ® core processing unit includes the EyeQ™ - Mobileye’s powerful vision system on a chip, a High Dynamic Range CMOS image sensor, Flash and SDRAM memories.
The aim of this paper is to show the possibilities offered by Scilab/Xcos to model and simulate aeraulic and HVAC systems. In particular we develop a new Xcos module combined with the use of Modelica language to show how aeraulic systems can be modeled and studied. In this paper we construct a reduced library composed by few elements: hoods, pipes and ideal junctions. The library can be easily extended to obtain a more complete toolbox. The developed library is tested on a simple aeraulic circuit.
The purpose of this tutorial is to show that Scilab can be considered as a powerful data mining tool, able to perform the widest possible range of important data mining tasks.
Modeling an ODE: 3 different approaches - Part 1Scilab
In this tutorial we show how to model a physical system described by ODE using Scilab standard programming language. The same model solution is also described in Xcos and Xcos + Modelica in two other tutorials.
Modeling an ODE: 3 different approaches - Part 2Scilab
In this tutorial we show how to model a physical system described by ODE using Xcos environment. The same model solution is also described in Scilab and Xcos + Modelica in two other tutorials.
In this Scilab tutorial, we introduce readers to the Control System Toolbox that is available in Scilab/Xcos and known as CACSD. This first tutorial is dedicated to "Linear Time Invariant" (LTI) systems and their representations in Scilab.
Customizing Xcos with new Blocks and PaletteScilab
In this tutorial, we show how to create and customize Xcos blocks and palettes. Moreover, we use the "Xcos toolbox skeleton" for a better result. The LHY model in Xcos scheme (already developed in other tutorials) is used as a starting point.
Types of errors
Among the most frequent sources of errors Brown counts
(1) interlingual transfer,
(2) intralingual transfer,
(3) context of learning,
and (4) various communication strategies the learners use
(Slides) Efficient Evaluation Methods of Elementary Functions Suitable for SI...Naoki Shibata
Naoki Shibata : Efficient Evaluation Methods of Elementary Functions Suitable for SIMD Computation, Journal of Computer Science on Research and Development, Proceedings of the International Supercomputing Conference ISC10., Volume 25, Numbers 1-2, pp. 25-32, 2010, DOI: 10.1007/s00450-010-0108-2 (May. 2010).
http://www.springerlink.com/content/340228x165742104/
http://freshmeat.net/projects/sleef
Data-parallel architectures like SIMD (Single Instruction Multiple Data) or SIMT (Single Instruction Multiple Thread) have been adopted in many recent CPU and GPU architectures. Although some SIMD and SIMT instruction sets include double-precision arithmetic and bitwise operations, there are no instructions dedicated to evaluating elementary functions like trigonometric functions in double precision. Thus, these functions have to be evaluated one by one using an FPU or using a software library. However, traditional algorithms for evaluating these elementary functions involve heavy use of conditional branches and/or table look-ups, which are not suitable for SIMD computation. In this paper, efficient methods are proposed for evaluating the sine, cosine, arc tangent, exponential and logarithmic functions in double precision without table look-ups, scattering from, or gathering into SIMD registers, or conditional branches. We implemented these methods using the Intel SSE2 instruction set to evaluate their accuracy and speed. The results showed that the average error was less than 0.67 ulp, and the maximum error was 6 ulps. The computation speed was faster than the FPUs on Intel Core 2 and Core i7 processors.
Exposure of Javier Solano, PhD Professor in Computational Physics and System Engineering, National University of Engineering Lima - Peru. Concept, definition and representation of algorithms. Tree constructs, Unified Modeling Languaje (UML).
A study of the Behavior of Floating-Point Errorsijpla
The dangers of programs performing floating-point computations are well known. This is due to numerical reliability issues resulting from rounding errors arising during the computations. In general, these round-off errors are neglected because they are small. However, they can be accumulated and propagated and lead to faulty execution and failures. Typically, in critical embedded systems scenario, these faults may cause dramatic damages (eg. failures of Ariane 5 launch and Patriot Rocket mission). The ufp (unit in the first place) and ulp (unit in the last place) functions are used to estimate maximum value of round-off errors. In this paper, the idea consists in studying the behavior of round-off errors, checking their numerical stability using a set of constraints and ensuring that the computation results of round-off errors do not become larger when solving constraints about the ufp and ulp values.
GENETIC ALGORITHM FOR FUNCTION APPROXIMATION: AN EXPERIMENTAL INVESTIGATIONijaia
Function Approximation is a popular engineering problems used in system identification or Equation
optimization. Due to the complex search space it requires, AI techniques has been used extensively to spot
the best curves that match the real behavior of the system. Genetic algorithm is known for their fast
convergence and their ability to find an optimal structure of the solution. We propose using a genetic
algorithm as a function approximator. Our attempt will focus on using the polynomial form of the
approximation. After implementing the algorithm, we are going to report our results and compare it with
the real function output.
PVS-Studio team is about to produce a technical breakthrough, but for now let...PVS-Studio
Static analysis is most useful when it is done on a regular basis. Especially when the project is rapidly developing, like the Blender project, for example. Now it's time to check it once more, and see what suspicious fragments we'll find this time.
Why electric vehicles need model-based design?
Because of the rising complexity in new vehicles, model-based design & systems engineering is needed to cascade the requirements and trace back any modification along the engineering lifecycle. Find out more in this presentation of a customer case about electric motor optimization.
Keynote of the French Space Agency CNES on the Asteroidlander MASCOT boarding the Hayabusa2 mission in collaboration with the Japanese Space Agency JAXA and the German Aerospace Center DLR
Faster Time to Market using Scilab/XCOS/X2C for motor control algorithm devel...Scilab
Rapid Prototyping becomes very popular for faster algorithm development. With a graphical representation of the algorithm and the possibility to simulate complete designs, engineers can help to reduce the time to market. A tight integration with MPLAB-X IDE allows the combination with standard C-coding to easily get mass production code. This solution was used to optimise a sensorless field oriented controlled PMSM motor driven pump efficiency. A model for closed loop simulation was developed using X2C blocks [1][2] for the FOC algorithm based on the existing application note AN1292 [3]. Enhancements to the original version were implemented and verified with simulation. The X2C Communicator was used to generate code of the new algorithm. With the online debugging capabilities and the scope functionality the algorithm was further tuned and optimized to achieve the highest possible efficiency of the pump.
Scilab and Xcos for Very Low Earth Orbits satellites modellingScilab
Very Low Earth Orbits are orbits in altitudes lower than 450 km. The interaction between the atmosphere particles and the surfaces of the spacecraft is responsible for the aerodynamic torques and forces. Simulating several aspects of the performance of a satellite flying in VLEO is very important to make decisions about the design of the spacecraft and the mission.
X2C -a tool for model-based control development and automated code generation...Scilab
Peter Dirnberger, Stefan Fragner
Nowadays, the market demands compact, stable, easy maintain-and customizable embedded systems. To meet these requirements, afast, simple and reliable implementation of control algorithms is crucial. This paper demonstrateshow model-based design with the help of Scilab/Xcosand X2C, developed by LCM,simplifiesand speedsup the development and implementation of controlalgorithms. As an example, acontrol schemefor a bearingless motoris presented.
A Real-Time Interface for Xcos – an illustrative demonstration using a batter...Scilab
As part of an EU-founded research project, the Scilab based development tool LoRra (Low-Cost Rapid Control Prototyping Platform) was created. This allows the realization of the continuously model based and highly automated Rapid Control Prototyping (RCP) design process for embedded software within the Scilab / Xcos environment (cf. Figure 1). Based on the application battery management system (BMS), this paper presents a Real-Time interface for Scilab.
Aircraft Simulation Model and Flight Control Laws Design Using Scilab and XCosScilab
The increasing demand in the aerospace industry for safety and performance has been requiring even more resourceful flight control laws in all market segments, since the airliners until the newest flying cars. The de facto standard for flight control laws design makes extensive use of tools supporting numerical computing and dynamic systems visual modeling, such that Scilab and XCos can nicely suit this kind of development.
Multiobjective optimization and Genetic algorithms in ScilabScilab
In this Scilab tutorial we discuss about the importance of multiobjective optimization and we give an overview of all possible Pareto frontiers. Moreover we show how to use the NSGA-II algorithm available in Scilab.
Online aptitude test management system project report.pdfKamal Acharya
The purpose of on-line aptitude test system is to take online test in an efficient manner and no time wasting for checking the paper. The main objective of on-line aptitude test system is to efficiently evaluate the candidate thoroughly through a fully automated system that not only saves lot of time but also gives fast results. For students they give papers according to their convenience and time and there is no need of using extra thing like paper, pen etc. This can be used in educational institutions as well as in corporate world. Can be used anywhere any time as it is a web based application (user Location doesn’t matter). No restriction that examiner has to be present when the candidate takes the test.
Every time when lecturers/professors need to conduct examinations they have to sit down think about the questions and then create a whole new set of questions for each and every exam. In some cases the professor may want to give an open book online exam that is the student can take the exam any time anywhere, but the student might have to answer the questions in a limited time period. The professor may want to change the sequence of questions for every student. The problem that a student has is whenever a date for the exam is declared the student has to take it and there is no way he can take it at some other time. This project will create an interface for the examiner to create and store questions in a repository. It will also create an interface for the student to take examinations at his convenience and the questions and/or exams may be timed. Thereby creating an application which can be used by examiners and examinee’s simultaneously.
Examination System is very useful for Teachers/Professors. As in the teaching profession, you are responsible for writing question papers. In the conventional method, you write the question paper on paper, keep question papers separate from answers and all this information you have to keep in a locker to avoid unauthorized access. Using the Examination System you can create a question paper and everything will be written to a single exam file in encrypted format. You can set the General and Administrator password to avoid unauthorized access to your question paper. Every time you start the examination, the program shuffles all the questions and selects them randomly from the database, which reduces the chances of memorizing the questions.
HEAP SORT ILLUSTRATED WITH HEAPIFY, BUILD HEAP FOR DYNAMIC ARRAYS.
Heap sort is a comparison-based sorting technique based on Binary Heap data structure. It is similar to the selection sort where we first find the minimum element and place the minimum element at the beginning. Repeat the same process for the remaining elements.
ACEP Magazine edition 4th launched on 05.06.2024Rahul
This document provides information about the third edition of the magazine "Sthapatya" published by the Association of Civil Engineers (Practicing) Aurangabad. It includes messages from current and past presidents of ACEP, memories and photos from past ACEP events, information on life time achievement awards given by ACEP, and a technical article on concrete maintenance, repairs and strengthening. The document highlights activities of ACEP and provides a technical educational article for members.
Using recycled concrete aggregates (RCA) for pavements is crucial to achieving sustainability. Implementing RCA for new pavement can minimize carbon footprint, conserve natural resources, reduce harmful emissions, and lower life cycle costs. Compared to natural aggregate (NA), RCA pavement has fewer comprehensive studies and sustainability assessments.
PROJECT FORMAT FOR EVS AMITY UNIVERSITY GWALIOR.ppt
Numerical analysis using Scilab: Error analysis and propagation
1. www.openeering.com
powered by
NUMERICAL ANALYSIS USING SCILAB:
ERROR ANALYSIS AND PROPAGATION
This tutorial provides a collection of numerical examples and advises on error
analysis and its propagation. All examples are developed in Scilab.
Level
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
2. Error analysis and propagation www.openeering.com page 2/10
Step 1: The purpose of this tutorial
The purpose of this Scilab tutorial is to provide a collection of numerical
examples that are typically part of numerical analysis courses.
This tutorial is intended to help readers familiarize with numerical methods
and their implementations, keeping under control the error propagation.
Here we provide some classical examples on error analysis and
propagation.
An introduction to
NUMERICAL ANALYSIS USING SCILAB
(Error study in Numerical Analysis)
Step 2: Roadmap
In this tutorial, after a brief introduction to the concept of numerical errors,
we analyze some examples in which numerical errors occur. These
examples are useful to understand how important is to pay attention to
error propagation when implementing numerical methods.
Descriptions Steps
Numerical errors 3-5
Examples 6-10
Conclusions and remarks 11-12
3. Error analysis and propagation www.openeering.com page 3/10
Step 3: Numerical error
What is allocated in a computer is only a subset of real number (using
IEEE 754 standard) and hence, a real number is represented in the
computer as , a fixed strings of digits. This limited amount of storage
introduces a rounding error (or round-off error). It is possible to prove the
following relation
with
| |
where is a constant that depends on the floating point system used to
represent the number (for double precision arithmetic is equal to
).
// Scilab command to obtain eps
// ----------------------------
%eps
Step 4: Truncation error
The next step is to study what happens when the basic arithmetic
operations are used.
We denote the computer arithmetic as , , , to distinguish them
from real arithmetic , , and respectively.
A part from the numerical error due to limited length in bits of registers, the
computer arithmetic introduces a further truncation error when results are
transfer from CPU to the memory. This error is caused by the fact that the
length in bits of the CPU register is greater than the one used to store
numbers.
As an example, if we sum two numbers and (to compute )
the corresponding machine operation can be written as
( )
with | | . The sum of two numbers involves the sum of the
two floating point operands. Since this operation is done in a register
of the computer, it is necessary to consider a further floating point
representation when the number is transferred to be stored into the
memory.
4. Error analysis and propagation www.openeering.com page 4/10
Step 5: Cancellation error
It is interesting to analyze the arithmetic operations when we consider
relative errors. For example, we want to analyze the sum operation:
| |
| |
in terms of the relative error of the input operands and . The relative
error for is defined as
| |
| |
A computer operation is considered numerically stable when
where and and are two input operands.
It is possible to prove that the computer operations and are the only
stable operations with respect to the rounding error. Conversely, for
addition we have:
(
| |
| |
| |
| |
)
A similar inequality holds for subtraction.
When , the right hand side of the inequality may be very high and
hence may generate a high relative error (cancellation error).
Cancellation error should be avoided whenever possible!
Example of cancellation error for subtraction operation
In this example we consider a decimal arithmetic with floating point where a
number is expressed in the following way:
with . is the exponent (or characteristic) of the representation while
is the mantissa of the representation. The mantissa has always a
fixed number of digits, in this case m.
For example, we can compute using a system with a mantissa of
4 digits for the number, while we use a mantissa of 8 digits for the internal
representations in the CPU register.
The example is done using .
From memory to registers:
Memory (mantissa = 4) Register (mantissa = 8)
Arithmetic operation with alignment of the exponent:
Register (mantissa = 8) Register with aligned exp.
+
From register to memory:
Register (mantissa = 8) Memory (mantissa = 4)
It is easy to compute the final step in which we subtract again 1 to evaluate
. As a result we obtain that is not equal to x.
5. Error analysis and propagation www.openeering.com page 5/10
Step 6: Two equivalent expressions
In this example we compare the following two equivalent expressions:
These two expressions are equivalent from an algebraic point of view; the
second expression is simply obtained from the first one through
simplification.
The first function suffers of the cancellation error when goes to zero.
This phenomenon has been explained in the previous step.
In the reported figure we have plotted the error . We
may see that the cancellation error is huge when is close to zero. This
phenomenon produces a loss of significant digits.
The Scilab script for the figure on the right is available in ex01.sce. The
code can be downloaded from the Openeering website.
(Error err in the range [-1e-07;1e-07])
6. Error analysis and propagation www.openeering.com page 6/10
Step 7: Two equivalent polynomials
In this example, we compare the two following polynomial expressions:
where the first expression is obtained from the second by expansion.
As depicted on the right, the second expression is numerically stable while
the first one is more unstable.
The Scilab script is reported in the function ex02.sce.
(Comparison between two algebraic equivalent polynomials)
7. Error analysis and propagation www.openeering.com page 7/10
Step 8: Derivative example
In this step, we study the computation of a derivative from a numerical
point of view. To approximate the first derivate, we use here the difference
quotient (a.k.a. Newton’s quotient):
For example, we may analyze the formula for the function at
point varying h in the following way:
The plot on the right visualizes the results.
From a mathematical point of view, when goes to zero, the formula
should assume the value of the first derivative. Intuitively, we may expect
the smaller the , the better the approximation. Unfortunately, because of
cancellation errors, it happens that the most reliable value for the derivate
is reached in (for , the value of the derivate is the same
as ).
The Scilab script for plot and table is reported in the function ex03.sce.
(Value of the derivative changing the value of h)
(Derivative example – table of results)
8. Error analysis and propagation www.openeering.com page 8/10
Step 9: Error analysis and optimal step
The Newton’s quotient to approximate the derivative contains two
sources of error:
Round-off error;
Truncation error.
This follows from the Taylor series expansion of :
where and hence:
The first term contributes to round-off error, while the second term gives
rise to a truncation error.
As reported on the right the total error can be expressed as
̅
From the above formula it is possible to compute the optimal step size .
Taking the derivative of the total error with respect to and setting this
quantity equal to zero, we have:
√
̅
This represents the optimal value for to minimize the total error.
Evaluation of the round-off error:
The round-off error for the Newton’s quotient can be written as:
|
( ) ( )
|
| |
where | | (remember that where | | ).
Moreover we ignore error from division by .
In order to evaluate this error, with small, we replace by
We do not know the signs of and , so we replace the difference
with ̅. This leads to:
̅
| |
̅
where | |.
Evaluation of the truncation error:
The truncation error is given by:
| |
where for small values of we replace by and | |.
9. Error analysis and propagation www.openeering.com page 9/10
Step 10: Exercise
It is possible to compute the second derivatives of a function using the
following approximation
Apply the above formula to compute the second derivative of the function
at a given point .
Moreover, prove the following estimate for the total error:
|
( ) ( ) ( )
|
̅
where | | and | |.
The upper bound error is minimized when has the value
√
̅
Hints: Using Taylor expansion for the function and to
the fourth order paying attention to the signs.
(Relative error for second derivative approximation)
(Second derivative approximation, table of results)
10. Error analysis and propagation www.openeering.com page 10/10
Step 11: Concluding remarks and References
In this tutorial we have collected a series of numerical examples written in
Scilab for the study of numerical errors.
1. Scilab Web Page: Available: www.scilab.org.
2. Openeering: www.openeering.com.
3. J. Higham, accuracy and Stability of Numerical Algorithms, SIAM
4. Atkinson, An Introduction to Numerical Analysis, Wiley
Step 12: Software content
To report a bug or suggest improvements please contact Openeering
team at the web site www.openeering.com.
Thank you for your attention,
Silvia Poles and Manolo Venturin
--------------
Main directory
--------------
ex01.sce : Expression example
ex02.sce : Polynomial example
ex03.sce : Derivative example
ex04.sce : Second derivative exercise
license.txt : The license file