John R. Hauser
2017 February 10
1. Introduction 2. Limitations 3. Acknowledgments and License 4. What TestFloat Does 5. Executing TestFloat 6. Operations Tested by TestFloat 6.1. Conversion Operations 6.2. Basic Arithmetic Operations 6.3. Fused Multiply-Add Operations 6.4. Remainder Operations 6.5. Round-to-Integer Operations 6.6. Comparison Operations 7. Interpreting TestFloat Output 8. Variations Allowed by the IEEE Floating-Point Standard 8.1. Underflow 8.2. NaNs 8.3. Conversions to Integer 9. Contact Information
Berkeley TestFloat is a small collection of programs for testing that an
implementation of binary floating-point conforms to the IEEE Standard for
Floating-Point Arithmetic.
All operations required by the original 1985 version of the IEEE Floating-Point
Standard can be tested, except for conversions to and from decimal.
With the current release, the following binary formats can be tested:
Included in the TestFloat package are the testsoftfloat
and
timesoftfloat
programs for testing the Berkeley SoftFloat software
implementation of floating-point and for measuring its speed.
Information about SoftFloat can be found at the SoftFloat Web page,
http://www.jhauser.us/arithmetic/SoftFloat.html
testsoftfloat
and timesoftfloat
programs are
expected to be of interest only to people compiling the SoftFloat sources.
This document explains how to use the TestFloat programs. It does not attempt to define or explain much of the IEEE Floating-Point Standard. Details about the standard are available elsewhere.
The current version of TestFloat is
For its part,
Compared to Release 2c and earlier, the set of TestFloat programs, as well as
the programs’ arguments and behavior, changed some with
TestFloat-history.html
TestFloat output is not always easily interpreted. Detailed knowledge of the IEEE Floating-Point Standard and its vagaries is needed to use TestFloat responsibly.
TestFloat performs relatively simple tests designed to check the fundamental
soundness of the floating-point under test.
TestFloat may also at times manage to find rarer and more subtle bugs, but it
will probably only find such bugs by chance.
Software that purposefully seeks out various kinds of subtle floating-point
bugs can be found through links posted on the TestFloat Web page,
http://www.jhauser.us/arithmetic/TestFloat.html
The TestFloat package was written by me,
Par Lab: Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery (Award #DIG07-10227), with additional support from Par Lab affiliates Nokia, NVIDIA, Oracle, and Samsung. ASPIRE Lab: DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA, Oracle, and Samsung.
The following applies to the whole of TestFloat
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the University of California. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

TestFloat is designed to test a floating-point implementation by comparing its behavior with that of TestFloat’s own internal floating-point implemented in software. For each operation to be tested, the TestFloat programs can generate a large number of test cases, made up of simple pattern tests intermixed with weighted random inputs. The cases generated should be adequate for testing carry chain propagations, and the rounding of addition, subtraction, multiplication, and simple operations like conversions. TestFloat makes a point of checking all boundary cases of the arithmetic, including underflows, overflows, invalid operations, subnormal inputs, zeros (positive and negative), infinities, and NaNs. For the interesting operations like addition and multiplication, millions of test cases may be checked.
TestFloat is not remarkably good at testing difficult rounding cases for
division and square root.
It also makes no attempt to find bugs specific to SRT division and the like
(such as the infamous Pentium division bug).
Software that tests for such failures can be found through links on the
TestFloat Web page,
http://www.jhauser.us/arithmetic/TestFloat.html
NOTE!
It is the responsibility of the user to verify that the discrepancies TestFloat
finds actually represent faults in the implementation being tested.
Advice to help with this task is provided later in this document.
Furthermore, even if TestFloat finds no fault with a floating-point
implementation, that in no way guarantees that the implementation is bug-free.
For each operation, TestFloat can test all five rounding modes defined by the IEEE Floating-Point Standard, plus possibly a sixth mode, round to odd (depending on the options selected when TestFloat was built). TestFloat verifies not only that the numeric results of an operation are correct, but also that the proper floating-point exception flags are raised. All five exception flags are tested, including the inexact flag. TestFloat does not attempt to verify that the floating-point exception flags are actually implemented as sticky flags.
For the
As a rule, TestFloat is not particular about the bit patterns of NaNs that
appear as operation results.
Any NaN is considered as good a result as another.
This laxness can be overridden so that TestFloat checks for particular bit
patterns within NaN results.
See -checkNaNs
option documented
for programs testfloat_ver
and testfloat
.
TestFloat normally compares an implementation of floating-point against the
Berkeley SoftFloat software implementation of floating-point, also created by
me.
The SoftFloat functions are linked into each TestFloat program’s
executable.
Information about SoftFloat can be found at the Web page
http://www.jhauser.us/arithmetic/SoftFloat.html
For testing SoftFloat itself, the TestFloat package includes a
testsoftfloat
program that compares SoftFloat’s
floating-point against another software floating-point implementation.
The second software floating-point is simpler and slower than SoftFloat, and is
completely independent of SoftFloat.
Although the second software floating-point cannot be guaranteed to be
bug-free, the chance that it would mimic any of SoftFloat’s bugs is low.
Consequently, an error in one or the other floating-point version should appear
as an unexpected difference between the two implementations.
Note that testing SoftFloat should be necessary only when compiling a new
TestFloat executable or when compiling SoftFloat for some other reason.
The TestFloat package consists of five programs, all intended to be executed from a command-line interpreter:
Each program has its own page of documentation that can be opened through the links in the table above.
testfloat_gen
Generates test cases for a specific floating-point operation. testfloat_ver
Verifies whether the results from executing a floating-point operation are as expected. testfloat
An all-in-one program that generates test cases, executes floating-point operations, and verifies whether the results match expectations. testsoftfloat
Like testfloat
, but for testing SoftFloat.timesoftfloat
A program for measuring the speed of SoftFloat (included in the TestFloat package for convenience).
To test a floating-point implementation other than SoftFloat, one of three
different methods can be used.
The first method pipes output from testfloat_gen
to a program
that:
testfloat_ver
to be checked for
correctness.
Assuming a vertical bar (|
) indicates a pipe between programs, the
complete process could be written as a single command like so:
The program in the middle is not supplied by TestFloat but must be created independently. If for some reason this program cannot take command-line arguments, thetestfloat_gen ... <type> | <program-that-invokes-op> | testfloat_ver ... <function>
-prefix
option of testfloat_gen
can communicate
parameters through the pipe.
A second method for running TestFloat is similar but has
testfloat_gen
supply not only the test inputs but also the
expected results for each case.
With this additional information, the job done by testfloat_ver
can be folded into the invoking program to give the following command:
Again, the program that actually invokes the floating-point operation is not supplied by TestFloat but must be created independently. Depending on circumstance, it may be preferable either to lettestfloat_gen ... <function> | <program-that-invokes-op-and-compares-results>
testfloat_ver
check and report suspected errors (first method) or
to include this step in the invoking program (second method).
The third way to use TestFloat is the all-in-one testfloat
program.
This program can perform all the steps of creating test cases, invoking the
floating-point operation, checking the results, and reporting suspected errors.
However, for this to be possible, testfloat
must be compiled to
contain the method for invoking the floating-point operations to test.
Each build of testfloat
is therefore capable of testing
only the floating-point implementation it was built to invoke.
To test a new implementation of floating-point, a new testfloat
must be created, linked to that specific implementation.
By comparison, the testfloat_gen
and testfloat_ver
programs are entirely generic;
one instance is usable for testing any floating-point implementation, because
implementation-specific details are segregated in the custom program that
follows testfloat_gen
.
Program testsoftfloat
is another all-in-one program specifically
for testing SoftFloat.
Programs testfloat_ver
, testfloat
, and
testsoftfloat
all report status and error information in a common
way.
As it executes, each of these programs writes status information to the
standard error output, which should be the screen by default.
In order for this status to be displayed properly, the standard error stream
should not be redirected to a file.
Any discrepancies that are found are written to the standard output stream,
which is easily redirected to a file if desired.
Unless redirected, reported errors will appear intermixed with the ongoing
status information in the output.
TestFloat can test all operations required by the original 1985 IEEE Floating-Point Standard except for conversions to and from decimal. These operations are:
More information about all these operations is given below.
In the operation names used by TestFloat, f16
, f32
, f64
,
extF80
, and
f128
.
TestFloat generally uses the same names for operations as Berkeley SoftFloat,
except that TestFloat’s names never include the M
that
SoftFloat uses to indicate that values are passed through pointers.
All conversions among the floating-point formats and all conversions between a
floating-point format and
Abbreviationsui32_to_f16 ui64_to_f16 i32_to_f16 i64_to_f16 ui32_to_f32 ui64_to_f32 i32_to_f32 i64_to_f32 ui32_to_f64 ui64_to_f64 i32_to_f64 i64_to_f64 ui32_to_extF80 ui64_to_extF80 i32_to_extF80 i64_to_extF80 ui32_to_f128 ui64_to_f128 i32_to_f128 i64_to_f128 f16_to_ui32 f32_to_ui32 f64_to_ui32 extF80_to_ui32 f128_to_ui32 f16_to_ui64 f32_to_ui64 f64_to_ui64 extF80_to_ui64 f128_to_ui64 f16_to_i32 f32_to_i32 f64_to_i32 extF80_to_i32 f128_to_i32 f16_to_i64 f32_to_i64 f64_to_i64 extF80_to_i64 f128_to_i64 f16_to_f32 f32_to_f16 f64_to_f16 extF80_to_f16 f128_to_f16 f16_to_f64 f32_to_f64 f64_to_f32 extF80_to_f32 f128_to_f32 f16_to_extF80 f32_to_extF80 f64_to_extF80 extF80_to_f64 f128_to_f64 f16_to_f128 f32_to_f128 f64_to_f128 extF80_to_f128 f128_to_extF80
ui32
and ui64
indicate
i32
and i64
indicate their signed counterparts.
These conversions all round according to the current rounding mode as relevant.
Conversions from a smaller to a larger floating-point format are always exact
and so require no rounding.
Likewise, conversions from
For the all-in-one testfloat
program, this list of conversion
operations requires amendment.
For testfloat
only, conversions to an integer type have names that
explicitly specify the rounding mode and treatment of inexactness.
Thus, instead of
as listed above, operations converting to integer type have names of these forms:<float>_to_<int>
The<float>_to_<int>_r_<round> <float>_to_<int>_rx_<round>
<round>
component is one of
‘near_even
’, ‘near_maxMag
’,
‘minMag
’, ‘min
’, or
‘max
’, choosing the rounding mode.
Any other indication of rounding mode is ignored.
The operations with ‘_r_
’ in their names never raise
the inexact exception, while those with ‘_rx_
’
raise the inexact exception whenever the result is not exact.
TestFloat assumes that conversions from floating-point to an integer type should raise the invalid exception if the input cannot be rounded to an integer representable in the result format. In such a circumstance:
If the result type is an unsigned integer, TestFloat normally expects the result of the operation to be the type’s largest integer value. In the case that the input is a negative number (not a NaN), a zero result may also be accepted.
If the result type is a signed integer and the input is a number (not a NaN), TestFloat expects the result to be the largest-magnitude integer with the same sign as the input. When a NaN is converted to a signed integer type, TestFloat allows either the largest postive or largest-magnitude negative integer to be returned.
When converting to an integer, if the rounding mode is odd
(possible only when the rounding mode is not in the function name), TestFloat
expects the result to be rounded not to an odd integer but rather to
minimum magnitude, the same as when the rounding mode is minMag
.
The following standard arithmetic operations can be tested:
The double-extended-precision (f16_add f16_sub f16_mul f16_div f16_sqrt f32_add f32_sub f32_mul f32_div f32_sqrt f64_add f64_sub f64_mul f64_div f64_sqrt extF80_add extF80_sub extF80_mul extF80_div extF80_sqrt f128_add f128_sub f128_mul f128_div f128_sqrt
extF80
) operations can be rounded
to reduced precision under rounding precision control.
For all floating-point formats except
f16_mulAdd f32_mulAdd f64_mulAdd f128_mulAdd
If one of the multiplication operands is infinite and the other is zero, TestFloat expects the fused multiply-add operation to raise the invalid exception even if the third operand is a quiet NaN.
For each format, TestFloat can test the IEEE Standard’s remainder operation. These operations are:
The remainder operations are always exact and so require no rounding.f16_rem f32_rem f64_rem extF80_rem f128_rem
For each format, TestFloat can test the IEEE Standard’s round-to-integer operation. For most TestFloat programs, these operations are:
f16_roundToInt f32_roundToInt f64_roundToInt extF80_roundToInt f128_roundToInt
Just as for conversions to integer types (testfloat
program is again an exception.
For testfloat
only, the round-to-integer operations have names of
these forms:
For the ‘<float>_roundToInt_r_<round> <float>_roundToInt_x
_r_
’ versions, the inexact exception
is never raised, and the <round>
component specifies
the rounding mode as one of ‘near_even
’,
‘near_maxMag
’, ‘minMag
’,
‘min
’, or ‘max
’.
The usual indication of rounding mode is ignored.
In contrast, the ‘_x
’ versions accept the usual
indication of rounding mode and raise the inexact exception whenever the
result is not exact.
This irregular system follows the IEEE Standard’s particular
specification for the round-to-integer operations.
If the rounding mode is odd
(possible only when the rounding mode
is not in the function name), TestFloat expects the result to be rounded
not to an odd integer but rather to minimum magnitude, the same as
when the rounding mode is minMag
.
The following floating-point comparison operations can be tested:
The abbreviationf16_eq f16_le f16_lt f32_eq f32_le f32_lt f64_eq f64_le f64_lt extF80_eq extF80_le extF80_lt f128_eq f128_le f128_lt
eq
stands for “equal” (=),
le
stands for “less than or equal” (≤), and
lt
stands for “less than” (<).
The IEEE Standard specifies that, by default, the less-than-or-equal and less-than comparisons raise the invalid exception if either input is any kind of NaN. The equality comparisons, on the other hand, are defined by default to raise the invalid exception only for signaling NaNs, not for quiet NaNs. For completeness, the following additional operations can be tested if supported:
Thef16_eq_signaling f16_le_quiet f16_lt_quiet f32_eq_signaling f32_le_quiet f32_lt_quiet f64_eq_signaling f64_le_quiet f64_lt_quiet extF80_eq_signaling extF80_le_quiet extF80_lt_quiet f128_eq_signaling f128_le_quiet f128_lt_quiet
signaling
equality comparisons are identical to the standard
operations except that the invalid exception should be raised for any
NaN input.
Similarly, the quiet
comparison operations should be identical to
their counterparts except that the invalid exception is not raised for
quiet NaNs.
Obviously, no comparison operations ever require rounding. Any rounding mode is ignored.
The “errors” reported by TestFloat programs may or may not really represent errors in the system being tested. For each test case tried, the results from the floating-point implementation being tested could differ from the expected results for several reasons:
For each reported error (or apparent error), a line of text is written to the default output. If a line would be longer than 79 characters, it is divided. The first part of each error line begins in the leftmost column, and any subsequent “continuation” lines are indented with a tab.
Each error reported is of the form:
The<inputs> => <observed-output> expected: <expected-output>
<inputs>
are the inputs to the operation.
Each output (observed or expected) is shown as a pair: the result value first,
followed by the exception flags.
For example, two typical error lines could be
In the first line, the inputs are-00.7FFF00 -7F.000100 => +01.000000 ...ux expected: +01.000000 ....x +81.000004 +00.1FFFFF => +01.000000 ...ux expected: +01.000000 ....x
-00.7FFF00
and
-7F.000100
, and the observed result is +01.000000
with flags ...ux
.
The trusted emulation result is the same but with different flags,
....x
.
Items such as -00.7FFF00
composed of a sign character
+
/-
)
Aside from the exception flags, there are ten data types that may be
represented.
Five are floating-point types: 0
(false) or a 1
(true).
A FFFFFFFF
is
−1, and 7FFFFFFF
is the largest positive value.
Floating-point values are written decomposed into their sign, encoded exponent,
and encoded significand.
First is the sign character +
or -
),.
), and lastly the encoded significand in hexadecimal.
For
Certain categories are easily distinguished (assuming the
+00.000
+0 +0F.000
1 +10.000
2 +1E.3FF
maximum finite value +1F.000
+infinity -00.000
−0 -0F.000
−1 -10.000
−2 -1E.3FF
minimum finite value (largest magnitude, but negative) -1F.000
−infinity
x
s are
not all 0):
+00.xxx
positive subnormal numbers +1F.xxx
positive NaNs -00.xxx
negative subnormal numbers -1F.xxx
negative NaNs
Likewise for other formats:
32-bit single 64-bit double 128-bit quadruple +00.000000
+000.0000000000000
+0000.0000000000000000000000000000
+0 +7F.000000
+3FF.0000000000000
+3FFF.0000000000000000000000000000
1 +80.000000
+400.0000000000000
+4000.0000000000000000000000000000
2 +FE.7FFFFF
+7FE.FFFFFFFFFFFFF
+7FFE.FFFFFFFFFFFFFFFFFFFFFFFFFFFF
maximum finite value +FF.000000
+7FF.0000000000000
+7FFF.0000000000000000000000000000
+infinity -00.000000
-000.0000000000000
-0000.0000000000000000000000000000
−0 -7F.000000
-3FF.0000000000000
-3FFF.0000000000000000000000000000
−1 -80.000000
-400.0000000000000
-4000.0000000000000000000000000000
−2 -FE.7FFFFF
-7FE.FFFFFFFFFFFFF
-7FFE.FFFFFFFFFFFFFFFFFFFFFFFFFFFF
minimum finite value -FF.000000
-7FF.0000000000000
-7FFF.0000000000000000000000000000
−infinity +00.xxxxxx
+000.xxxxxxxxxxxxx
+0000.xxxxxxxxxxxxxxxxxxxxxxxxxxxx
positive subnormals +FF.xxxxxx
+7FF.xxxxxxxxxxxxx
+7FFF.xxxxxxxxxxxxxxxxxxxxxxxxxxxx
positive NaNs -00.xxxxxx
-000.xxxxxxxxxxxxx
-0000.xxxxxxxxxxxxxxxxxxxxxxxxxxxx
negative subnormals -FF.xxxxxx
-7FF.xxxxxxxxxxxxx
-7FFF.xxxxxxxxxxxxxxxxxxxxxxxxxxxx
negative NaNs
The 8
digit in
the significands):
+0000.0000000000000000
+0 +3FFF.8000000000000000
1 +4000.8000000000000000
2 +7FFE.FFFFFFFFFFFFFFFF
maximum finite value +7FFF.8000000000000000
+infinity -0000.0000000000000000
−0 -3FFF.8000000000000000
−1 -4000.8000000000000000
−2 -7FFE.FFFFFFFFFFFFFFFF
minimum finite value -7FFF.8000000000000000
−infinity
Lastly, exception flag values are represented by five characters, one character
per flag.
Each flag is written as either a letter or a period (.
) according
to whether the flag was set or not by the operation.
A period indicates the flag was not set.
The letter used to indicate a set flag depends on the flag:
For example, the notation
v
invalid exception i
infinite exception (“divide by zero”) o
overflow exception u
underflow exception x
inexact exception
...ux
indicates that the
underflow and inexact exception flags were set and that the other
three flags (invalid, infinite, and overflow) were not
set.
The exception flags are always written following the value returned as the
result of the operation.
The IEEE Floating-Point Standard admits some variation among conforming implementations. Because TestFloat expects the two implementations being compared to deliver bit-for-bit identical results under most circumstances, this leeway in the standard can result in false errors being reported if the two implementations do not make the same choices everywhere the standard provides an option.
The standard specifies that the underflow exception flag is to be raised
when two conditions are met simultaneously:
A result is tiny when its magnitude is nonzero yet smaller than any normalized
floating-point number.
The standard allows tininess to be determined either before or after a result
is rounded to the destination precision.
If tininess is detected before rounding, some borderline cases will be flagged
as underflows even though the result after rounding actually lies within the
normal floating-point range.
By detecting tininess after rounding, a system can avoid some unnecessary
signaling of underflow.
All the TestFloat programs support options -tininessbefore
and
-tininessafter
to control whether TestFloat expects tininess on
underflow to be detected before or after rounding.
One or the other is selected as the default when TestFloat is compiled, but
these command options allow the default to be overridden.
Loss of accuracy occurs when the subnormal format is not sufficient to represent an underflowed result accurately. The original 1985 version of the IEEE Standard allowed loss of accuracy to be detected either as an inexact result or as a denormalization loss; however, few if any systems ever chose the latter. The latest standard requires that loss of accuracy be detected as an inexact result, and TestFloat can test only for this case.
The IEEE Standard gives the floating-point formats a large number of NaN encodings and specifies that NaNs are to be returned as results under certain conditions. However, the standard allows an implementation almost complete freedom over which NaN to return in each situation.
By default, TestFloat does not check the bit patterns of NaN results.
When the result of an operation should be a NaN, any NaN is considered as good
as another.
This laxness can be overridden with the -checkNaNs
option of
programs testfloat_ver
and testfloat
.
In order for this option to be sensible, TestFloat must have been compiled so
that its internal floating-point implementation (SoftFloat) generates the
proper NaN results for the system being tested.
Conversion of a floating-point value to an integer format will fail if the source value is a NaN or if it is too large. The IEEE Standard does not specify what value should be returned as the integer result in these cases. Moreover, according to the standard, the invalid exception can be raised or an unspecified alternative mechanism may be used to signal such cases.
TestFloat assumes that conversions to integer will raise the invalid
exception if the source value cannot be rounded to a representable integer.
In such cases, TestFloat expects the result value to be the largest-magnitude
positive or negative integer or zero, as detailed earlier in
At the time of this writing, the most up-to-date information about TestFloat
and the latest release can be found at the Web page
http://www.jhauser.us/arithmetic/TestFloat.html


Pair Programming
by
niquola
ag;)e days 2014
Teamlead of
health samurai
@ waveaccess/choice-hospital-systems
github/niquola
/
@niquola


Package org.drip.spline.basis
Interface FunctionSetBuilderParams
- All Known Implementing Classes:
ExponentialMixtureSetParams
,ExponentialRationalSetParams
,ExponentialTensionSetParams
,KaklisPandelisSetParams
,PolynomialFunctionSetParams
public interface FunctionSetBuilderParams
FunctionSetBuilderParams is an empty stub class whose derived implementations hold the per segment
basis set parameters.
- Module = Computational Core Module
- Library = Spline Builder Library
- Project = Basis Splines and Linear Compounders across a Broad Family of Spline Basis Functions
- Package = Basis Spline Construction/Customization Parameters
- Author:
- Lakshmi Krishnamurthy


Zones List
| Id | Name | Serial | Show Zone | Zone BIND File | Edit Zone SOA | Delete |
|---|---|---|---|---|---|---|
| Id | Zone Name | Serial | Zone | Zone BIND File | Edit Zone SOA | Delete |
| Id | Name | Serial | Show Zone | Zone BIND File | Edit Zone SOA | Delete |
|---|---|---|---|---|---|---|
| Id | Zone Name | Serial | Zone | Zone BIND File | Edit Zone SOA | Delete |


|
VA-API
2.6.0.pre1
|
Huffman table for JPEG decoding. More...
#include <va.h>
Public Attributes | |
| uint8_t | load_huffman_table [2] |
| Specifies which huffman_table is valid. | |
| struct { | |
| uint8_t num_dc_codes [16] | |
| Number of Huffman codes of length i + 1 (Li). | |
| uint8_t dc_values [12] | |
| Value associated with each Huffman code (Vij). | |
| uint8_t num_ac_codes [16] | |
| Number of Huffman codes of length i + 1 (Li). | |
| uint8_t ac_values [162] | |
| Value associated with each Huffman code (Vij). | |
| uint8_t pad [2] | |
| Padding to 4-byte boundaries. Must be set to zero. | |
| } | huffman_table [2] |
| Huffman tables indexed by table identifier (Th). | |
| uint32_t | va_reserved [VA_PADDING_LOW] |
| Reserved bytes for future use, must be zero. | |
DC table (up to 12 categories) | |
AC table (2 special codes + up to 16 * 10 codes) |
Huffman table for JPEG decoding.
This structure holds the complete Huffman tables. This is an aggregation of all Huffman table (DHT) segments maintained by the application. i.e. up to 2 Huffman tables are stored in there for baseline profile.
The load_huffman_table array can be used as a hint to notify the VA driver implementation about which table(s) actually changed since the last submission of this buffer.


aCF=RandomInteger((-5,-1),(1,5));
bCF=RandomInteger((-5,-1),(1,5));
cCF=RandomInteger(-5,5);
f=aCF x^2+bCF x + cCF;
extremumName=if (aCF>0, "minimum", "maximum");
thePlot=Plot2D (f, -bCF/(2aCF)-2, -bCF/(2aCF)+2, red) +PlotGrid{}0;
Complete the square.
f
\(=\)
aCF (x+ bCF/(2aCF))^2 + cCF - aCF (bCF/(2aCF))^2
thePlot+PlotSetId("theCanvas");
Find the extremumName point on the curve \(y=\)f.
Your answer should be in the format \((a,b)\).
extremumName point=
(-bCF/(2aCF),(x=-bCF/(2 aCF); f)_2)


New Quote
Quote:
Quote is required!
Author:
Author is required!
Submitted By:
Your name is required!
Add Quote


---
layout: post
title: Rock you like a hurricane...
date: '2008-12-12T23:22:00.000-06:00'
author: Jabell
tags:
- Music
- Graphs
- Humor
modified_time: '2008-12-12T23:23:55.283-06:00'
blogger_id: tag:blogger.com,1999:blog-19739956.post-3982299941311603599
blogger_orig_url: http://theabellsix.blogspot.com/2008/12/rock-you-like-hurricane.html
---
more music charts


No definition in Astah file
Networked ontologies used by RSMO:
| Ontology | Relation | Integration Level |
| SPO - Software Process Ontology | High | |
| COM - Core Ontology on Measurement (external) | High | |
| SwAO - Software Artifact Ontology |
Figure 1 presents the packages of the RSMO Modularization.
Figure 1. RSMO Modularization.
No definition in Astah file
No definition in Astah file
Figure 2 presents the conceptual model of the Software Measurement Entities subontology.
Figure 2. Software Measurement Entities conceptual model.
No definition in Astah file
No definition in Astah file
Figure 3 presents the conceptual model of the Software Measurement Process subontology.
Figure 3. Software Measurement Process conceptual model.
No definition in Astah file
No definition in Astah file
Figure 4 presents the conceptual model of the Software Measurement Planning subontology.
Figure 4. Software Measurement Planning conceptual model.
No definition in Astah file
No definition in Astah file
Figure 5 presents the conceptual model of the Measurement Execution subontology.
Figure 5. Measurement Execution conceptual model.
No definition in Astah file
No definition in Astah file
Figure 6 presents the conceptual model of the Measurement Analysis subontology.
Figure 6. Measurement Analysis conceptual model.
No definition in Astah file
The following table shows the definitions for RSMO concepts.
| Concept | Definition |
| Analysis Result Description | Information Item that records the Analysis Result produced in a Software Measurement Analysis.
Ex.: the record of the analysis result: the schedule performance index of the Project P has improved in the last three months and the project is now adherent to the agreed schedule. |
| Business Goal | Goal that expresses the intention for which strategic actions are planned and performed.
Ex.: Increase the client’s satisfaction degree. |
| Data Analysis | Activity for analyzing the selected Measured Values and producing the Analysis Result Description that records the Analysis Result.
|
| Data Collection | Activity for collecting and storing data for the Software-Related Measure indicated in the selected Software Measurement Plan Item. |
| Information Need Description | Information Item that documents the description of an Information Need.
Ex.: the record of the information need What is the delivered defects density?. |
| Information Needs Identification | Activity for identifying and recording the Information Needs to be included in the Software Measurement Plan. Information Needs are identified from the established Software Measurement Goals. |
| Measurable Software-Related Entity | Measurable Entity related to software.
Ex.: a software project, a standard process. |
| Measurable Software-Related Entity Type | Type of Measurable Entities related to software.
Ex.: the Requirements Engineering Standard Process is a measurable software-related entity of the Standard Process type. |
| Measure Description | Information Item that documents the description of a Software-Related Measure.
Ex.: the record of the software-related measure delivered defects density. |
| Measured Value Description | Information Item that records a Measured Value.
Ex.: the record of the measured value 0.75. |
| Measurement Analysis Procedure | Procedure applied to analyze Measured Values obtained for a Software-Related Measure.
|
| Measurement Analyst | Role played by the Stakeholder in charge of Software Measurement Analysis.
Ex.: If John (a Person Stakeholder) was in charge of a software measurement analysis, then he played the role of measurement analyst. |
| Measurement Context | Situation in which a Software Measurement Execution was performed.
Ex.: an example of measurement context for a software measurement execution that obtained the measured value 0.75 for the software-related measure schedule performance index to the Project P could be: measurement performed one month after substituting two of the team members with two members less experienced. |
| Measurement Executor | Role played by the Stakeholder in charge of Software Measurement Execution.
Ex.: If Mary (a Person Stakeholder) was in charge of a software measurement execution, then she played the role of measurement executor. |
| Measurement Goals Establishment | Activity for establishing and recording the Software Measurement Goals to be included in the Software Measurement Plan. |
| Measurement Manager | Role played by the Stakeholder in charge of Software Measurement Planning.
Ex.: If John (a Person Stakeholder) was in charge of a software measurement planning, then he played the role of measurement manager. |
| Measurement Plan Item Selection | Activity for selecting the Software Measurement Plan Item to be used to guide the Software Measurement Execution. The selected Software Measurement Plan Item indicates the Software-Related Measured to be applied in the Software Measurement Execution and the Operational Definition of Measure to be considered. |
| Measurement Planning Start | Activity for defining the Software Measurement Plan structure, its initial information (e.g., organization to which it was defined and elaboration date) and starting its elaboration. |
| Measurement Result Reporting | Activity for communicating the Analysis Result Description to the relevant Stakeholders. |
| Measures Identification | Activity for identifying and recording the Software-Related Measures to be included in the Software Measurement Plan. Software-Related Measures are identified from Information Needs in the sense that Measures must meet the identified Information Needs.
|
| Operational Definition of Measure | Information Item that specifies information regarding data collection and analysis of a Software-Related Measure. An Operational Definition of Measure indicates: Measurement Procedure, Measurement Periodicity, Measurement Moment, Measurement Responsible, Measurement Analysis Procedure, Measurement Analysis Periodicity, Measurement Analysis Moment, and Measurement Analysis Responsible. |
| Operational Definition of Measure Establishment | Activity for establishing the Operational Definitions of Measures for the identified Software-Related Measures. |
| Periodicity |
|
| Planning Item Documentation | Activity for documenting Measurement Planning Items. Each Measurement Planning Item includes a Software Measurement Goal Description, an Information Need Description, a Software-Related Measure and an Operational Definition of Measure. Measurement Planning Items produced during the Software Measurement Analysis are part of the Software Measurement Plan produced in that activity. |
| Selection of Data for Analysis | Activity for selecting the Measured Values of the selected Software-Related Measures to be analyzed in the Software Measurement Analysis. |
| Selection of Entity for Measurement | Activity for selecting the Software-Related Measurable Entity to be measured in the Software Measurement Execution. The selected entity type must be the Software-Related Measurable Entity Type indicated in the Operational Definition of Measure defined in the selected Software Measurement Plan Item. |
| Selection of Measurement Goals for Analysis | Activity for selecting the Software Measurement Goal to be monitored by using information provided by the Software Measurement Analysis. |
| Selection of Measures for Analysis | Activity for selecting, among the Software-Related Measures related to the selected Software Measurement Goal the ones to be analyzed in the Software Measurement Analysis. |
| Software Goal | Goal that expresses the intention for which software-related actions are planned and performed. Software Goals are based on Business Goals.
Ex.: the software goal Improve software products quality could be defined based on the business goal Increase the client’s satisfaction degree. |
| Software Measurement Analysis | Activity for analyzing Measured Values collected for Software-Related Measures aiming to characterize a Software-Related Measurable Entity and provide information related to a Software Measurement Goal.
Ex.: a software measurement analysis that analyzed the measured values 0.75, 0.9 e 1, collected for the measure schedule performance index to characterize the software-related measurable entity Project P. |
| Software Measurement Execution | Activity for measuring a Software-Related Measurable Entity by applying a Software-Related Measure and obtaining a Measured Value.
Ex.: the software measurement execution that applied the software-related measure schedule performance index to measure the Project P and obtained the measured value 0.75. |
| Software Measurement Goal | Measurement Goal related to software. Software Measurement Goals are based on Business Goals or Software Goals.
Ex.: the measurement goal Decrease defects in delivered products could be defined based on the software goal Improve software products quality. |
| Software Measurement Goal Description | Information Item that documents the description of a Software Measurement Goal.
Ex.: the record of the software measurement goal Decrease defects in delivered products. |
| Software Measurement Plan | Document produced during Software Measurement Planning. It is composed of Software Measurement Planning Items.
Ex.: the Software Measurement Plan defined for the Organization O. |
| Software Measurement Planning | Activity for planning the software measurement, i.e., for determining the Software Measurement Goals to be monitored, the Information Needs to be considered, the Software-Related Measures to be collected to meet the Information Needs and the Operational Definition of Measure to be considered. |
| Software Measurement Planning Item | Measurement Planning Item related to software. It is an Information Item produced during Software Measurement Planning and it is composed of a Software Measurement Goal Description, an Information Need Description, a Measure Description and an Operational Definition of Measure.
Ex.: the software measurement planning item composed of the software measurement goal description Decrease defects in delivered products, the information need description What is the delivered defects density?, the measure description delivered defects density and an operational definition of measure established to the software-related measure delivered defects density. |
| Software Measurement Process | The Software Measurement Process is a Process with the purpose of collecting, analyzing, and reporting data relating to the products developed and the processes used to develop them, aiming to support effective processes management and objectively demonstrate products quality.
|
| Software Project Measurement Plan | A Software Measurement Plan defined for a Project.
Ex.: the Software Project Measurement Plan defined for the Project P. |
| Software-Related Measure | Measure used to quantify Measurable Elements of Measurable Software-Related Entities.
Ex.: the software-related measure number of lines of code could be used to quantify the measurable element size of measurable-related entities of the Software type. |
| Analysis Result Description |
Analysis Result Description (0..1) describes (1..1) Analysis Result
Data Analysis creates Analysis Result Description
Measurement Result Reporting uses Analysis Result Description
Software Measurement Analysis (1..1) \creates (1..1) Analysis Result Description
| Business Goal |
Software Goal (0..*) based on (1..*) Business Goal
Software Measurement Goal (0..*) based on (1..*) Business Goal
<<event>> Data Analysis |
Data Analysis creates Analysis Result Description
Software Measurement Analysis <>-- Data Analysis
<<event>> Data Collection |
Data Collection creates Measured Value Description
Software Measurement Execution <>-- Data Collection
<<subkind>> Information Need Description |
Information Need Description (0..1) describes (1..1) Information Need
Information Needs Identification creates Information Need Description
Software Measurement Planning Item (0..*) <>-- (1..1) Information Need Description
<<event>> Information Needs Identification |
Information Needs Identification creates Information Need Description
Software Measurement Planning <>-- Information Needs Identification
| Measurable Software-Related Entity |
Measurable Software-Related Entity (0..*) instance of (1..1) Measurable Software-Related Entity Type
Software Measurement Execution (0..*) measures (1..1) Measurable Software-Related Entity
| Measurable Software-Related Entity Type |
Measurable Software-Related Entity (0..*) instance of (1..1) Measurable Software-Related Entity Type
Operational Definition of Measure (0..*) indicates (1..1) Measurable Software-Related Entity Type
<<subkind>> Measure Description |
Measure Description (0..*) describes (1..1) Software-Related Measure
Software Measurement Planning Item (0..*) <>-- (1..1) Measure Description
Measures Identification creates Measure Description
| Measured Value Description |
Measured Value Description (0..1) describes (1..1) Measured Value
Software Measurement Execution (1..1) \creates (1..1) Measured Value Description
Data Collection creates Measured Value Description
Software Measurement Analysis (0..*) \uses (1..*) Measured Value Description
| Measurement Analysis Procedure |
Measurement Analysis Procedure (0..*) applies to (1..*) Measure
Operational Definition of Measure (0..*) indicates (0..1) Measurement Analysis Procedure
Software Measurement Analysis (0..*) adopts (1..1) Measurement Analysis Procedure
<<role>> Measurement Analyst |
Measurement Analyst (1..1) in charge of (1..*) Software Measurement Analysis
| Measurement Context |
Software Measurement Execution (1..*) occurs in (1..1) Measurement Context
<<role>> Measurement Executor |
Measurement Executor (1..1) in charge of (1..*) Software Measurement Execution
Software Measurement Execution (0..*) performed by (1..1) Measurement Executor
<<event>> Measurement Goals Establishment |
Measurement Goals Establishment creates Software Measurement Goal Description
Software Measurement Planning <>-- Measurement Goals Establishment
<<role>> Measurement Manager |
Measurement Manager (1..1) in charge of (1..*) Software Measurement Planning
<<event>> Measurement Plan Item Selection |
Software Measurement Execution <>-- Measurement Plan Item Selection
<<event>> Measurement Planning Start |
Measurement Planning Start creates Software Measurement Plan
Software Measurement Planning <>-- Measurement Planning Start
<<event>> Measurement Result Reporting |
Measurement Result Reporting uses Analysis Result Description
Software Measurement Analysis <>-- Measurement Result Reporting
<<event>> Measures Identification |
Measures Identification creates Measure Description
Software Measurement Planning <>-- Measures Identification
<<subkind>> Operational Definition of Measure |
Operational Definition of Measure (0..*) indicates (1..1) Measurable Software-Related Entity Type
Operational Definition of Measure (0..*) indicates (1..1) Measurable Element
Operational Definition of Measure (0..*) defined for (1..1) Software-Related Measure
Operational Definition of Measure (0..*) indicates (1..1) Measurement Procedure
Operational Definition of Measure (0..*) indicates (0..*)  Operational Definition of Measure
Software Measurement Analysis (0..*) is performed according to (0..*) Operational Definition of Measure
<<event>> Operational Definition of Measure Establishment |
Operational Definition of Measure Establishment creates Operational Definition of Measure
Software Measurement Planning <>-- Operational Definition of Measure Establishment
| Periodicity |
Operational Definition of Measure (0..*) indicates (0..1) Periodicity
<<event>> Planning Item Documentation |
Planning Item Documentation creates Software Measurement Planning Item
Planning Item Documentation changes Software Measurement Plan
Software Measurement Planning <>-- Planning Item Documentation
<<event>> Selection of Data for Analysis |
Software Measurement Analysis <>-- Selection of Data for Analysis
<<event>> Selection of Entity for Measurement |
Software Measurement Execution <>-- Selection of Entity for Measurement
<<event>> Selection of Measurement Goals for Analysis |
Software Measurement Analysis <>-- Selection of Measurement Goals for Analysis
<<event>> Selection of Measures for Analysis |
Software Measurement Analysis <>-- Selection of Measures for Analysis
| Software Goal |
Software Goal (0..*) based on (1..*) Business Goal
Software Measurement Goal (0..*) based on (1..*) Software Goal
<<event>> Software Measurement Analysis |
Software Measurement Analysis <>-- Selection of Measurement Goals for Analysis
Software Measurement Analysis <>-- Selection of Measures for Analysis
Software Measurement Analysis <>-- Selection of Data for Analysis
Software Measurement Analysis <>-- Data Analysis
Software Measurement Analysis <>-- Measurement Result Reporting
Software Measurement Analysis uses Software Measurement Plan
Software Measurement Analysis (0..*) adopts (1..1) Measurement Analysis Procedure
Software Measurement Analysis (0..*) (0..1) Performed Activity
Software Measurement Analysis (0..*) is performed according to (0..*) Operational Definition of Measure
Software Measurement Analysis (0..*) \uses (1..*) Measured Value Description
Software Measurement Analysis (0..*) considers (1..*) Software-Related Measure
Software Measurement Analysis (0..*) performed based on (1..*) Software Measurement Planning Item
Software Measurement Analysis (1..1) \creates (1..1) Analysis Result Description
Measurement Analyst (1..1) in charge of (1..*) Software Measurement Analysis
Software Measurement Process <>-- Software Measurement Analysis
<<event>> Software Measurement Execution |
Software Measurement Execution <>-- Measurement Plan Item Selection
Software Measurement Execution <>-- Selection of Entity for Measurement
Software Measurement Execution <>-- Data Collection
Software Measurement Execution uses Software Measurement Plan
Software Measurement Execution (1..*) occurs in (1..1) Measurement Context
Software Measurement Execution (0..*) occurs in (1..1) Performed Activity
Software Measurement Execution (0..*) performed by (1..1) Measurement Executor
Software Measurement Execution (0..*) measures (1..1) Measurable Software-Related Entity
Software Measurement Execution (0..*) applies (1..1) Software-Related Measure
Software Measurement Execution (0..*) performed based on (1..1) Software Measurement Planning Item
Software Measurement Execution (0..*) /performed based on (1..1) Operational Definition of Measure
Software Measurement Execution (1..1) \creates (1..1) Measured Value Description
Software Measurement Process <>-- Software Measurement Execution
Measurement Executor (1..1) in charge of (1..*) Software Measurement Execution
| Software Measurement Goal |
Software Measurement Goal (0..*) based on (1..*) Software Goal
Software Measurement Goal (0..*) based on (1..*) Business Goal
Software Measurement Goal Description (0..1) describes (1..1) Software Measurement Goal
<<subkind>> Software Measurement Goal Description |
Software Measurement Goal Description (0..1) describes (1..1) Software Measurement Goal
Software Measurement Planning Item (0..*) <>-- (1..1) Software Measurement Goal Description
Measurement Goals Establishment creates Software Measurement Goal Description
<<subkind>> Software Measurement Plan |
Software Measurement Plan (1..1) <>-- (0..*) Software Measurement Planning Item
Software Measurement Plan (1..1) depicts (0..*) Software Measurement Planning Item
Planning Item Documentation changes Software Measurement Plan
Software Measurement Execution uses Software Measurement Plan
Software Measurement Planning (1..*) produces (1..1) Software Measurement Plan
Measurement Planning Start creates Software Measurement Plan
Software Measurement Analysis uses Software Measurement Plan
<<event>> Software Measurement Planning |
Software Measurement Planning <>-- Measurement Goals Establishment
Software Measurement Planning <>-- Information Needs Identification
Software Measurement Planning <>-- Measures Identification
Software Measurement Planning <>-- Operational Definition of Measure Establishment
Software Measurement Planning <>-- Measurement Planning Start
Software Measurement Planning <>-- Planning Item Documentation
Software Measurement Planning (1..1) produces (1..*) Software Measurement Planning Item
Software Measurement Planning (1..*) produces (1..1) Software Measurement Plan
Measurement Manager (1..1) in charge of (1..*) Software Measurement Planning
Software Measurement Process <>-- Software Measurement Planning
<<subkind>> Software Measurement Planning Item |
Software Measurement Planning Item (0..*) <>-- (1..1) Operational Definition of Measure
Software Measurement Planning Item (0..*) <>-- (1..1) Measure Description
Software Measurement Planning Item (0..*) <>-- (1..1) Information Need Description
Software Measurement Planning Item (0..*) <>-- (1..1) Software Measurement Goal Description
Planning Item Documentation creates Software Measurement Planning Item
Software Measurement Plan (1..1) <>-- (0..*) Software Measurement Planning Item
Software Measurement Plan (1..1) depicts (0..*) Software Measurement Planning Item
Software Measurement Execution (0..*) performed based on (1..1) Software Measurement Planning Item
Software Measurement Planning (1..1) produces (1..*) Software Measurement Planning Item
Software Measurement Analysis (0..*) performed based on (1..*) Software Measurement Planning Item
| Software Measurement Process |
Software Measurement Process <>-- Software Measurement Planning
Software Measurement Process <>-- Software Measurement Execution
Software Measurement Process <>-- Software Measurement Analysis
| Software Project Measurement Plan |
Software Project Measurement Plan (0..*) defined for (1..1) Software Project
| Software-Related Measure |
Operational Definition of Measure (0..*) defined for (1..1) Software-Related Measure
Software Measurement Execution (0..*) applies (1..1) Software-Related Measure
Measure Description (0..*) describes (1..1) Software-Related Measure
Software Measurement Analysis (0..*) considers (1..*) Software-Related Measure


OSX app to export FileMaker Layouts as PDF & XML.
Tested on OSX 10.6. May work on higher versions but I don’t expect ot to run on OSX 10.10.
Tested with FileMaker Pro Advanced Versions 9–11. Higher versions may or may not work.
If the database files do not use custom menus and the “Layout mode” menu item is present, it may work with “FileMaker Pro”.
The application is flaky. Start, expand all, select all, export & quit. Don’t play around.
I’ve observed 5%–20% damaged pdf files. The app just does a copy of all layout elements and writes the clipboard contents into a file.
The source code is in a horrible state and the outline code is buggy. Usually I need this app once per project, so the incentive for a more polished app is near zero. YMMV.
dropbox: http://goo.gl/AZVMVj
Make sure that you use “FileMaker Pro Advanced”. If you can open all files and put them into layout mode, it should work with “FileMaker Pro”.
Make sure you have a backup of the databases.
Start your FileMaker database with [Full Access] and make sure all files are open.
Start FMPLayoutExporter
The app will iterate through all the database files and switch them to layout mode.
A window will open with an outline of all the database files.
press cmd-a (select all), right arrow (expand outline nodes), cmd-a
click “Export”
A dialog opens. Select an empty folder where the export should go. Click “Export”.
WARNING: If the folder is not empty, identical filenames will be overwritten without asking.
For each layout selected in the outline, 2 files will be created: DBNAME_LAYOUTINDEX_LAYOUTNAME.pdf and DBNAME_LAYOUTINDEX_LAYOUTNAME.xml
Quit the application.
The app is written in Python with py2app & PyObjc. It controls FileMaker via AppleEvents.
On launch, the app detects a running FileMaker, gets it’s documents, tries to go to layout mode for each document and finally opens it’s own window with with an outline of the files & layouts to select.
At export it goes to each layout of each document, does a “select all” & copy, extracts the PDF and XML data from the pasteboard and writes them into files.
A note: when copying items in FileMaker layouts, FileMaker places several data formats on the pasteboard (which was called clipboard in it’s former incarnation). It used to XML, PDF & PICT (the classic Mac image format). With FileMaker 11 this has been reduced to XML & PDF; PICT has been deprecated for many years. FMPLayoutExporter tells FileMaker to select all layout items and copy them and looks at what FileMaker has put on the pasteboard. If it finds the types for XML and/or PDF, they will be written into files.
For this to work, the Filemaker application needs to be set to the english or german language. FMPLayoutExporter literally tells Filemaker to “select menu item ”Copy“ of menu ”Edit". So all those necessary menus must be present and selectable.
FMPLayoutExporter can be made to work with other languages as long as the exact wording for “Edit”, “Select All”, “Copy”, “View”, Layout Mode“, ”Tools“, ”Custom Menus“ and ”[Standard FileMaker Menus]" are known.
Install
Python 2.7 (2.7.9 is current) https://www.python.org/downloads/
In Terminal do
python setup.py py2app
in the source folder.
v0.1.0 2015–04–04 - OSX 10.6, pyobjc 3.1 update of a 8 year old beginners project
v0.2.0 2015–04–05 - Completely replaced the outline internals. Selection now works.


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 10-12
A delicious dessert which would work just as well with other seasonal soft fruits.
Preheat the oven to 200C/400F/Gas 6. Line three 23cm/9in springform cake tins with greaseproof paper, brush with a little melted butter and dust with flour, shaking out any excess flour.
Place the eggs and sugar in large bowl and set it over a bowl of barely simmering water, making sure the bottom of the bowl does not touch the water. Beat with an electric whisk until the mixture is thick and fluffy then remove the bowl from the pan and continue beating for three minutes.
Stir in the melted butter then fold in the sifted flour using a large metal spoon. Divide the mixture between two cake tins and bake for 25 minutes. Let the sponges cool for five minutes then remove from the cake tins and sprinkle with the raspberry liqueur.
Meanwhile, make the mousse. Place one and a half punnets of the raspberries in a bowl with the raspberry liqueur and icing sugar. Stir gently until the sugar has dissolved then set aside.
Pulse the remaining raspberries in a food processor, or mash with a fork, until they are pulpy but not completely smooth. Place the crushed raspberries in a small saucepan with the caster sugar, heat gently until the sugar has dissolved then remove the pan from the heat. Squeeze the water from the gelatine and add it to the pan, stirring until it has completely dissolved, then mix in the whole raspberries.
Transfer the mixture to a bowl and set aside to cool. (You could place the bowl over iced water to speed up the cooling process.) When the raspberry mixture is cold and starting to set, whisk the cream until it forms soft peaks then gently fold it into the raspberries.
Place one of the cooked sponges in the bottom of the third cake tin. Spoon over three-quarters of the mousse then place the second sponge on top and add the remaining mousse.
Arrange the sliced strawberries and mint leaves over the top of the cake, leave in fridge until set then carefully remove the cake from the tin and serve.


Joint Distribution of the \(i^{th}\) and \(j^{th}\) Order Statistics
The joint distribuiton of \(Y_{(i)}\) and \(Y_{(j)}\) is
$$f_{Y_{(i)},Y_{(j)}}(u,v)=nf_Y(u)(n-1)f_Y(v)\binom{n-2}{i-1,j-1-i,n-j}\left[F_Y(u)\right]^{i-1}\left[F_Y(v)-F_Y(u)\right]^{j-1-i}\left[1-F_Y(v)\right]^{n-j}$$
Let's break this down with a counting argument similar to the univariate case (without loss of generality assume i < j):
- n = # of ways to choose \(i^{th}\) smallest.
- \(f_Y(u)\) is the pdf for the \(i^{th}\) smallest.
- n-1 = # of ways to choose \(j^{th}\) smallest from remaining sample members.
- \(f_Y(v)\) is the pdf for the \(j^{th}\) smallest.
- \(\binom{n-2}{i-1,j-1-i,n-j}\) = # of ways to partition the remaining n-2 observations to be less than \(Y_{(i)}\), between \(Y_{(i)}\) and \(Y_{(j)}\), and greater than \(Y_{(j)}\).
- \(\left[F_Y(u)\right]^{i-1}\) corresponds to having i-1 sample members less than \(Y_{(i)}\).
- \(\left[F_Y(v)-F_Y(u)\right]^{j-1-i}\) corresponds to having j-1-i sample members between \(Y_{(i)}\) and \(Y_{(j)}\).
- \(\left[1-F_Y(v)\right]^{n-j}\) corresponds to having n-j sample members larger than \(Y_{(j)}\).
Multinomial Argument
Consider our number of trials to be our sample size \(n\). For each observation we have 5 categories (let \(\epsilon\) be a very small number):
- Observation is less than \(u-\epsilon/2\).
- Observation is between \(u-\epsilon/2\) and \(u+\epsilon/2\).
- Observation is between \(u+\epsilon/2\) and \(v-\epsilon/2\).
- Observation is between \(v-\epsilon/2\) and \(v+\epsilon/2\).
- Observation is greater than \(v+\epsilon/2\)
The probability of falling into each category is
- \(p_1\) = P(observation in category 1) = \(F_Y(u-\epsilon/2)\approx F_Y(u)\)
- \(p_2\) = P(observation in category 2) \(\approx \epsilon f_Y(u)\approx f_Y(u)\)
- \(p_3\) = P(observation in category 3) = \(F_Y(v-\epsilon/2)-F_Y(u+\epsilon/2)\)
- \(p_4\) = P(observation in category 4) \(\approx \epsilon f_Y(v)\approx f_Y(v)\)
- \(p_5\) = P(observation in category 5) = \(1-F_{Y}(v+\epsilon/2)\approx 1-F_Y(v)\)
Now if we find the probability of getting exactly \(i-1\) observations in category 1, exactly 1 observation in category 2, exactly \(j-1-i\) observations in category 3, exactly 1 observation in category 4, and exactly n-j observations in category 5, we will have our pdf above!
This argument could easily be extended to find the joint distribution of three or more order statistics!


-
4/22/2006 - Retroweaver 1.2.3 Released. This is mainly a bug fix release.
See the Changelog for details.
-
4/5/2006 - Retroweaver 1.2.2 Released. This is mainly a bug fix release.
See the Changelog for details.
-
3/13/2006 - Retroweaver 1.2.1 Released. This is mainly a bug fix release.
See the Changelog for details.
-
2/26/2006 - Retroweaver 1.2 Released. This marks the merging of retroweaver-ng back into the official project.
Changes include: bug fixes, patches, new architecture for byte code generation, new options to weave jar files and WeaveRunner, a new ClassLoader to weave classes at runtime. See the Changelog for details.
-
1/19/2005 - Retroweaver 1.1 Released. This is primarily a new feature release, with support for reference verification, an ant task, and a separate runtime jar.
-
10/12/2004 - Retroweaver 1.0 FCS Released. This is the final 1.0 release of Retroweaver coinciding with the JDK 1.5 FCS release.
-
3/24/2004 - Retroweaver 1.0 RC5 Released. This is a bug fix release.
-
3/22/2004 - Retroweaver 1.0 RC4 Released. This release contains more support for optimization of autoboxing and new support for java.lang.Iterable and java.lang.Enum.
-
3/17/2004 - Retroweaver 1.0 RC3 Released - Release Candidate 3 of Retroweaver Version 1 has just been released.
-
3/10/2004 - Retroweaver 1.0 RC1 Released - Release Candidate 1 of Retroweaver Version 1 has just been released. This first initial release contains support for all JDK1.5 features aside from enumerations and annotations.


Server Address not valid
Server Address required
Copyright Eric Pignet 2018
https://github.com/ericpignet/squeeze-mobile


Man jailed for 10 months for possessing 32,000 xanax tablets
A 40-year-old north Belfast man has been jailed for 10 months for possessing 32,000 Xanax tablets.
Several tubs filled with the Class C drug were found during a police search of a house in the Newington Street area of Belfast in November 2017.
Sean Rooney was linked to the find via fingerprints, and when his flat at Oceanic Avenue was subsequently searched, 28 grams of herbal cannabis was found in the property.
Despite initial denials, Rooney admitted to possessing the cannabis and to possessing the Xanax with intent to supply.
Belfast Crown Court heard Rooney turned to drugs and began to self-medicate following a family tragedy, and has since regretted his involvement with possessing the Xanax as he has seen the destructive affect these drugs have on people.
Crown prosecutor Philip Henry told Judge Stephen Fowler QC that the 32,000 Xanax tablets were located under the stairs of a house which was unoccupied and undergoing renovation and which was searched on November 17, 2017.
When officers searched Rooney's apartment five months later, on April 5 2018, small amounts of cannabis were found at various locations.
Rooney was arrested the day his flat was searched, and while he admitted possessing the Xanax tablets, he made the case he had been storing the tablets in exchange for £100 to clear his drugs debt.
Defence barrister Joel Lindsay said Rooney suffered a family tragedy in 2013 which resulted in him self-medicating.
Regarding the Xanax, Mr Lindsay said it was his client's case that he was handed a couple of bin bags which he stored but that he had "no idea" there were so many tablets and "sheer panic set in" when he realised the number involved.
Judge Fowler said: "It's clear the reason for him becoming involved in this is to fund his own drug habit - a significant addiction to cannabis."
The judge also spoke of "the scourge of these drugs in society and the misery it heaps on others" and ordered the tablets and cannabis seized be destroyed.


NFSSERVCTL
Section: Linux Programmer's Manual (2)Updated: 1997-07-16
Index Return to Main Contents
NAME
nfsservctl - syscall interface to kernel nfs daemonSYNOPSIS
#include <linux/nfsd/syscall.h> long nfsservctl(int cmd, struct nfsctl_arg *argp, union nfsctl_res *resp);
DESCRIPTION
/* * These are the commands understood by nfsctl(). */ #define NFSCTL_SVC 0 /* This is a server process. */ #define NFSCTL_ADDCLIENT 1 /* Add an NFS client. */ #define NFSCTL_DELCLIENT 2 /* Remove an NFS client. */ #define NFSCTL_EXPORT 3 /* export a file system. */ #define NFSCTL_UNEXPORT 4 /* unexport a file system. */ #define NFSCTL_UGIDUPDATE 5 /* update a client's UID/GID map. */ #define NFSCTL_GETFH 6 /* get an fh (used by mountd) */ struct nfsctl_arg { int ca_version; /* safeguard */ union { struct nfsctl_svc u_svc; struct nfsctl_client u_client; struct nfsctl_export u_export; struct nfsctl_uidmap u_umap; struct nfsctl_fhparm u_getfh; unsigned int u_debug; } u; } union nfsctl_res { struct knfs_fh cr_getfh; unsigned int cr_debug; };
RETURN VALUE
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.CONFORMING TO
This call is Linux-specific.COLOPHON
This page is part of release 3.22 of the Linux man-pages project. A description of the project, and information about reporting bugs, can be found at http://www.kernel.org/doc/man-pages/.
Index
This document was created by man2html, using the manual pages.
Time: 05:33:04 GMT, December 24, 2015


griddit is a simple interface for image-based subreddits providing emphasis on images instead of their captions.
To get started, simply search for a subreddit. Best results when the subreddit has a lot of images.
Project by Karan Goel.


A widely used language! Built on the .NET Framework, it's no surprise C# was designed by Microsoft, the same company that introduced Windows to the computing world. You're in for a lot of fun. If you need any help, I can write you an invoice in advanced.
You Slytherin, you. Besides having a very cute logo, Python is a relatively easy to learn, hard to master language. Maybe Snape has a potion that'll make you a genius at it in no time.
"If you like piña coladas"... No? Oh, right, this is JavaScript.  Designed by a lad over at Netscape(if you even remember who are they), JavaScript is used in almost every website you visit... including this one!
Don't be fooled by Swift's age compared to the competition, this language was written by industry giant Apple Inc. and has quickly become a technological behemoth. Mainly used for building apps in iOS and similar Apple products, Swift is the new kid on the block, the sidewalk, your driveway, frontdoor, garage, and anywhere you can yell, "Hey Siri!" and get a response. Love Apple? Have an iPad? Download Swift Playgrounds from the App Store for a free interactive beginners tutorial with Swift!


pgAdmin 4 (macOS)
Download
Maintainer: Dave Page
A macOS App Bundle containing the pgAdmin 4 Desktop Runtime and Web application is available for macOS 10.12 and above.
Notes
Nightly snapshot builds generated from the head of the master branch are available here.
These packages are macOS appbundles. To install, mount the disk image using the finder, and drag the pgAdmin 4 appbundle to the desired location.
Whilst the macOS packages and disk images are signed with an Apple-issued digital signing key, a separate GPG signature is also provided for each downloadable file in the corresponding .asc file. The public key for these signatures can be found on OpenPGP keyservers, for example here. The GPG key UID is Package Manager (Package Signing Key<EMAIL_ADDRESS>and has a fingerprint of E869 7E2E EF76 C02D 3A63 3277 8881 B2A8 2109 76F2.
Alternative Distributions


[
Elance-oDesk
]
John Doe
"Life is so..."
Account
Profile
Account Settings
Help
Sign Out
Channels
#{{workroom.name}}
{{workroom.numMessages}}
+ Create new #channel...
+ Join existing #channel...
People
@{{workroom.name}}
{{workroom.numMessages}}
+ All People...
+ Invite to #channel...
×
1:1 Message
Find by name...
{{user.displayname}} ({{user.username}})
×
Create new #channel
×
Browse Workrooms
Select the #channels you'd like to join:
Filter:
#{{workroom.name}}
Join
×
Invite to #channel
Type or select the names of team members that you would like to invite:
{{user.displayname}} ({{user.username}})


1 Chronicles 10:14
And inquired not of the LORD: therefore he slew him, and turned the kingdom unto David the son of Jesse.


[ all classes ]
[ core.components.factories ]
Coverage Summary for Class: UserFactory (core.components.factories)
| Class | Class, % | Method, % | Line, % |
|---|---|---|---|
| UserFactory | 100% (1/ 1) | 40% (2/ 5) | 47.6% (10/ 21) |
1 package core.components.factories;
2
3 import core.components.Manager;
4 import core.components.User;
5 import core.system.MyVelibSystem;
6
7 import java.awt.*;
8 import java.util.List;
9
10 /**
11 * The UserFactory class : This is the factory to create and add new users. We will always add users to a given system
12 * It is uses the simple factory design pattern
13 */
14 public class UserFactory {
15
16 /**
17 * This method is responsible for adding a (new) user to a system with some initial information.
18 *
19 * @param system the system that the user is requesting to be inserted in
20 * @param name the name of the new user
21 * @param coordinate the (initial) coordinate of the user
22 * @param creditCardNumber the credit card number of the new user
23 * @param money the (initial) money of the user in the application
24 * @return the User instance
25 */
26 public static User addUser(MyVelibSystem system, String name, Point coordinate, int creditCardNumber, double money) {
27 User user = new User(name, coordinate, creditCardNumber, money);
28 List<User> users = system.getUsers();
29 users.add(user);
30 system.setUsers(users);
31 return user;
32 }
33
34 /**
35 * This method is responsible for adding a (new) user to a system with some initial information. It can be simpler in some cases.
36 *
37 * @param system the system that the user is requesting to be inserted in
38 * @param name the name of the new user
39 * @param creditCardNumber the credit card number of the new user
40 * @return the User instance
41 */
42 public static User addUser(MyVelibSystem system, String name, int creditCardNumber) {
43 User user = new User(name, new Point(0, 0), creditCardNumber, 0);
44 List<User> users = system.getUsers();
45 users.add(user);
46 system.setUsers(users);
47 return user;
48 }
49
50
51 /**
52 * This method is responsible for adding a (new) manager to a system with some initial information.
53 *
54 * @param system the system that the user is requesting to be inserted in
55 * @param name the name of the new user
56 * @param coordinate the (initial) coordinate of the manager
57 * @param creditCardNumber the credit card number of the new user
58 * @param money the (initial) money of the user in the application
59 * @return the Manager instance
60 */
61 public static Manager addManager(MyVelibSystem system, String name, Point coordinate, int creditCardNumber, double money) {
62 Manager user = new Manager(name, coordinate, creditCardNumber, money);
63 List<User> users = system.getUsers();
64 users.add(user);
65 system.setUsers(users);
66 return user;
67 }
68
69 /**
70 * This method is responsible for adding a (new) manager to a system with some initial information. It can be simpler in some cases.
71 *
72 * @param system the system that the user is requesting to be inserted in
73 * @param name the name of the new user
74 * @param creditCardNumber the credit card number of the new manager
75 * @return the Manager instance
76 */
77 public static Manager addManager(MyVelibSystem system, String name, int creditCardNumber) {
78 Manager user = new Manager(name, new Point(0, 0), creditCardNumber, 0);
79 List<User> users = system.getUsers();
80 users.add(user);
81 system.setUsers(users);
82 return user;
83 }
84
85
86 }
87
88


|
Bounce3
A poll based debounce library with a small RAM footprint
|
Functions | |
| Bounce3::Bounce3 (uint8_t pin, uint8_t mode, uint8_t pin_mode) | |
| Bounce3::Bounce3 (uint8_t pin, uint8_t mode) | |
| Bounce3::Bounce3 (uint8_t pin) | |
| Bounce3::Bounce3 | ( | uint8_t | pin, |
| uint8_t | mode, | ||
| uint8_t | pin_mode | ||
| ) |
| pin | Which digital pin to read |
| mode | A bitwise-or of config values (default: B3_MODE_ONESHOT | B3_ACTIVE_LOW ) |
| pin_mode | If you wish to specify pinMode (default: INPUT_PULLUP) |
| Bounce3::Bounce3 | ( | uint8_t | pin, |
| uint8_t | mode | ||
| ) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Bounce3::Bounce3 | ( | uint8_t | pin | ) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.


#include <WithdrawTypes.hpp>
◆ WithdrawWithSignature()
| hsrcore::blockchain::WithdrawWithSignature::WithdrawWithSignature |
( |
const Address |
owner_arg = Address() | ) |
|
|
inline |
◆ decrypt_memo_data() [1/2]
| oMessageStatus hsrcore::blockchain::WithdrawWithSignature::decrypt_memo_data |
( |
const fc::ecc::private_key & |
receiver_key, |
|
|
bool |
ignore_owner = false |
|
) |
| const |
◆ decrypt_memo_data() [2/2]
| ExtendedMemoData hsrcore::blockchain::WithdrawWithSignature::decrypt_memo_data |
( |
const fc::sha512 & |
secret | ) |
const |
◆ encrypt_memo_data() [1/3]
| PublicKeyType hsrcore::blockchain::WithdrawWithSignature::encrypt_memo_data |
( |
const fc::ecc::private_key & |
one_time_private_key, |
|
|
const fc::ecc::public_key & |
to_public_key, |
|
|
const fc::ecc::private_key & |
from_private_key, |
|
|
const std::string & |
memo_message, |
|
|
const fc::ecc::public_key & |
memo_pub_key, |
|
|
MemoFlagsEnum |
memo_type = from_memo , |
|
|
bool |
use_stealth_address = true |
|
) |
| |
◆ encrypt_memo_data() [2/3]
| void hsrcore::blockchain::WithdrawWithSignature::encrypt_memo_data |
( |
const fc::sha512 & |
secret, |
|
|
const MemoData & |
memo_content |
|
) |
| |
◆ encrypt_memo_data() [3/3]
| void hsrcore::blockchain::WithdrawWithSignature::encrypt_memo_data |
( |
const fc::sha512 & |
secret, |
|
|
const ExtendedMemoData & |
memo_content |
|
) |
| |
◆ memo
| optional<TransferMemo> hsrcore::blockchain::WithdrawWithSignature::memo |
◆ owner
| Address hsrcore::blockchain::WithdrawWithSignature::owner |
◆ type
The documentation for this struct was generated from the following files:


class: center, middle, inverse, title-slide # Fitting ### Machine Learning with R
Basel R Bootcamp
### October 2019 --- layout: true
        www.therbootcamp.com      Machine Learning with R | October 2019
 --- .pull-left45[ # Fitting

 Models are actually <high>families of models</high>, with every parameter combination specifying a different model. To fit a model means to <high>identify</high> from the family of models <high>the specific model that fits the data best</high>. ] .pull-right45[

 adapted from explainxkcd.com
 ] --- # Which of these models is better? Why?  --- # Which of these models is better? Why?  --- # Loss function .pull-left45[ Possible <high>the most important concept</high> in statistics and machine learning. The loss function defines some <high>summary of the errors committed by the model</high>.
 `$$\Large Loss = f(Error)$$`
 Two purposes

  Purpose 	  Description

  Fitting 	  Find parameters that minimize loss function.

  Evaluation 	  Calculate loss function for fitted model.

 ] .pull-right45[  ] --- class: center, middle <high>
Regression
</high>
Decision Trees

Random Forests
 --- # Regression .pull-left45[ In [regression](https://en.wikipedia.org/wiki/Regression_analysis), the criterion `\(Y\)` is modeled as the <high>sum</high> of <high>features</high> `\(X_1, X_2, ...\)` <high>times weights</high> `\(\beta_1, \beta_2, ...\)` plus `\(\beta_0\)` the so-called the intercept.

 `$$\large \hat{Y} = \beta_{0} + \beta_{1} \times X_1 + \beta_{2} \times X2 + ...$$`

 The weight `\(\beta_{i}\)` indiciates the <high>amount of change</high> in `\(\hat{Y}\)` for a change of 1 in `\(X_{i}\)`. Ceteris paribus, the <high>more extreme</high> `\(\beta_{i}\)`, the <high>more important</high> `\(X_{i}\)` for the prediction of `\(Y\)` (Note: the scale of `\(X_{i}\)` matters too!). If `\(\beta_{i} = 0\)`, then `\(X_{i}\)` <high>does not help</high> predicting `\(Y\)` ] .pull-right45[  ] --- # Regression loss .pull-left45[
  Mean Squared Error (MSE)

<high>Average squared distance</high> between predictions and true values?
 $$ MSE = \frac{1}{n}\sum_{i \in 1,...,n}(Y_{i} - \hat{Y}_{i})^{2}$$
 Mean Absolute Error (MAE)

<high>Average absolute distance</high> between predictions and true values?
 $$ MAE = \frac{1}{n}\sum_{i \in 1,...,n} \lvert Y_{i} - \hat{Y}_{i} \rvert$$
 ] .pull-right45[  ] --- # Fitting .pull-left45[ There are two fundamentally different ways to find the set of parameters that minimizes loss.  Analytically  In rare cases, the parameters can be <high>directly calculated</high>, e.g., using the normal equation: `$$\boldsymbol \beta = (\boldsymbol X^T\boldsymbol X)^{-1}\boldsymbol X^T\boldsymbol y$$`  Numerically  In most cases, parameters need to be found using a <high>directed trial and error</high>, e.g., gradient descent: `$$\boldsymbol \beta_{n+1} = \boldsymbol \beta_{n}+\gamma \nabla F(\boldsymbol \beta_{n})$$` ] .pull-right45[

 adapted from me.me
 ] --- .pull-left45[ # Fitting

 There are two fundamentally different ways to find the set of parameters that minimizes loss.  Analytically  In rare cases, the parameters can be <high>directly calculated</high>, e.g., using the normal equation: `$$\boldsymbol \beta = (\boldsymbol X^T\boldsymbol X)^{-1}\boldsymbol X^T\boldsymbol y$$`  Numerically  In most cases, parameters need to be found using a <high>directed trial and error</high>, e.g., gradient descent: `$$\boldsymbol \beta_{n+1} = \boldsymbol \beta_{n}+\gamma \nabla F(\boldsymbol \beta_{n})$$` ] .pull-right45[
<br2>

 adapted from dunglai.github.io

 adapted from dunglai.github.io
 ] --- # 2 types of supervised problems .pull-left5[ There are two types of supervised learning problems that can often be approached using the same model. Regression Regression problems involve the <high>prediction of a quantitative feature</high>. E.g., predicting the cholesterol level as a function of age. Classification Classification problems involve the <high>prediction of a categorical feature</high>. E.g., predicting the type of chest pain as a function of age. ] .pull-right4[

 ] --- # Logistic regression .pull-left45[ In [logistic regression](https://en.wikipedia.org/wiki/Logistic_regression), the class criterion `\(Y \in (0,1)\)` is modeled also as the <high>sum of feature times weights</high>, but with the prediction being transformed using a <high>logistic link function</high>:

 `$$\large \hat{Y} = Logistic(\beta_{0} + \beta_{1} \times X_1 + ...)$$`

 The logistic function <high>maps predictions to the range of 0 and 1</high>, the two class values.

 $$ Logistic(x) = \frac{1}{1+exp(-x)}$$ ] .pull-right45[  ] --- # Logistic regression .pull-left45[ In [logistic regression](https://en.wikipedia.org/wiki/Logistic_regression), the class criterion `\(Y \in (0,1)\)` is modeled also as the <high>sum of feature times weights</high>, but with the prediction being transformed using a <high>logistic link function</high>:

 `$$\large \hat{Y} = Logistic(\beta_{0} + \beta_{1} \times X_1 + ...)$$`

 The logistic function <high>maps predictions to the range of 0 and 1</high>, the two class values.

 $$ Logistic(x) = \frac{1}{1+exp(-x)}$$ ] .pull-right45[  ] --- # Classification loss - two ways .pull-left45[ Distance Logloss is <high>used to fit the parameters</high>, alternative distance measures are MSE and MAE. `$$\small LogLoss = -\frac{1}{n}\sum_{i}^{n}(log(\hat{y})y+log(1-\hat{y})(1-y))$$` `$$\small MSE = \frac{1}{n}\sum_{i}^{n}(y-\hat{y})^2, \: MAE = \frac{1}{n}\sum_{i}^{n} \lvert y-\hat{y} \rvert$$` Overlap Does the <high>predicted class match the actual class</high>. Often preferred for <high>ease of interpretation</high>. `$$\small Loss_{01}=\frac{1}{n}\sum_i^n I(y \neq \lfloor \hat{y} \rceil)$$` ] .pull-right45[  ] --- # Confusion matrix .pull-left45[ The confusion matrix <high>tabulates prediction matches and mismatches</high> as a function of the true class. The confusion matrix permits specification of a number of <high>helpful performance metrics</high>.
  Confusion matrix

  	  <eq>ŷ = 1</eq> 	  <eq>ŷ = 0</eq>

  <eq>y = 1</eq> 	   True positive (TP) 	   False negative (FN)

  <eq>y = 0</eq> 	   False positive (FP) 	   True negative (TN)

 ] .pull-right45[ Accuracy: Of all cases, what percent of predictions are correct? `$$\small Acc. = \frac{TP + TN}{ TP + TN + FN + FP} = 1-Loss_{01}$$`

 Sensitivity: Of the truly Positive cases, what percent of predictions are correct? `$$\small Sensitivity = \frac{TP}{ TP +FN }$$` Specificity: Of the truly Negative cases, what percent of predictions are correct?

 `$$\small Specificity = \frac{TN}{ TN + FP }$$` ] --- # Confusion matrix .pull-left45[ The confusion matrix <high>tabulates prediction matches and mismatches</high> as a function of the true class. The confusion matrix permits specification of a number of <high>helpful performance metrics</high>.
  Confusion matrix

  	  <eq>"Default"</eq> 	  <eq>"Repay"</eq>

  <eq>Default</eq> 	   TP = 3 	   FN = 1

  <eq>Repay</eq> 	   FP = 1 	   TN = 2

 ] .pull-right45[ Accuracy: Of all cases, what percent of predictions are correct? `$$\small Acc. = \frac{TP + TN}{ TP + TN + FN + FP} = 1-Loss_{01}$$`

 Sensitivity: Of the truly Positive cases, what percent of predictions are correct? `$$\small Sensitivity = \frac{TP}{ TP +FN }$$` Specificity: Of the truly Negative cases, what percent of predictions are correct?

 `$$\small Specificity = \frac{TN}{ TN + FP }$$` ] --- class: center, middle

 # Let's fit regression models with `caret`!  --- # `caret` .pull-left45[ <mono>caret</mono>'s key fitting functions

  Function 	  Description

  <mono>trainControl()</mono> 	  Choose settings for how fitting should be carried out.

  <mono>train()</mono> 	  Specify the model and find *best* parameters.

  <mono>postResample()</mono> 	  Evaluate model performance (fitting or prediction) for regression.

  <mono>confusionMatrix()</mono> 	  Evaluate model performance (fitting or prediction) for classification.

 ] .pull-right45[ ```r # Step 1: Define control parameters # trainControl() ctrl <- trainControl(...) # Step 2: Train and explore model # train() mod <- train(...) summary(mod) mod$finalModel # see final model # Step 3: Assess fit # predict(), postResample(), fon fit <- predict(mod) postResample(fit, truth) confusionMatrix(fit, truth) ```   ] --- # `trainControl()` .pull-left45[ `trainControl()` controls how `caret` fits an ML model. For now, set `method = "none"` to keep things simple. More in the session on optimization. ```r # Fit the model without any # advanced parameter tuning methods ctrl <- trainControl(method = "none") ``` ] .pull-right45[ ```r ?trainControl ```  ] --- # `train()` .pull-left4[ `train()` is the fitting <high>workhorse</high> of `caret`, offering you <high>200+ models</high> just by changing the <high>method</high> argument! <mono>train()</mono>'s key arguments

  Argument 	  Description

  <mono>form</mono> 	  Formula specifying features and criterion.

  <mono>data</mono> 	  Training data.

  <mono>method</mono> 	  The model (algorithm).

  <mono>trControl</mono> 	  Control parameters for fitting.

  <mono>tuneGrid</mono>, <mono>preProcess</mono> 	  Cool stuff for later.

 ] .pull-right5[ ```r # Fit a regression model predicting Price income_mod <- train(form = income ~ ., # Formula data = baselers, # Training data method = "glm", # Regression trControl = ctrl) # Control Param's income_mod ``` ``` Generalized Linear Model 1000 samples 19 predictor No pre-processing Resampling: None ``` ] --- # `train()` .pull-left4[ `train()` is the fitting <high>workhorse</high> of `caret`, offering you <high>200+ models</high> just by changing the <high>method</high> argument! <mono>train()</mono>'s key arguments

  Argument 	  Description

  <mono>form</mono> 	  Formula specifying features and criterion.

  <mono>data</mono> 	  Training data.

  <mono>method</mono> 	  The model (algorithm).

  <mono>trControl</mono> 	  Control parameters for fitting.

  <mono>tuneGrid</mono>, <mono>preProcess</mono> 	  Cool stuff for later.

 ] .pull-right5[ ```r # Fit a random forest predicting Price income_mod <- train(form = income ~ .,# Formula data = baselers, # Training data method = "rf", # Random Forest trControl = ctrl) # Control Param's income_mod ``` ``` Random Forest 1000 samples 19 predictor No pre-processing Resampling: None ``` ] --- .pull-left4[ # `train()`

 `train()` is the fitting <high>workhorse</high> of `caret`, offering you <high>200+ models</high> just by changing the <high>method</high> argument! Find all 200+ models [here](http://topepo.github.io/caret/available-models.html). ] .pull-right5[

  ] --- # `train()` .pull-left4[ The criterion must be the right type: <mono>numeric</mono> criterion = Regression
 <mono>factor</mono> criterion = Classification! ``` # A tibble: 5 x 5 Default Age Gender Cards Education <dbl> <dbl> <chr> <dbl> <dbl> 1 0 45 M 3 11 2 1 36 F 2 14 3 0 76 F 5 12 4 1 25 M 2 17 5 1 36 F 3 12 ``` ] .pull-right5[ ```r # Will be a regression task loan_mod <- train(form = Default ~ ., data = Loans, method = "glm", trControl = ctrl) # Will be a classification task load_mod <- train(form = factor(Default) ~ ., data = Loans, method = "glm", trControl = ctrl) ``` ] --- # <mono>.$finalModel</mono> .pull-left4[ The `train()` function returns a `list` with a key object called `finalModel` - this is your <high>final machine learning model</high>! Access the model with `mod$finalModel` and <high>explore</high> the object with generic functions:

  Function 	  Description

  <mono>summary()</mono> 	  Overview of the most important results.

  <mono>names()</mono> 	  See all named elements you can access with $.

 ] .pull-right5[ ```r # Create a regression object income_mod <- train(form = income ~ age + height, data = baselers) # Training data # Look at all named outputs names(income_mod$finalModel) ``` ``` [1] "coefficients" "residuals" "fitted.values" [4] "effects" "R" "rank" [ reached getOption("max.print") -- omitted 28 entries ] ``` ```r # Access specific outputs income_mod$finalModel$coefficients ``` ``` (Intercept) age height 177.084 151.786 3.466 ``` ] --- # `predict()` .pull-left5[ The `predict()` function <high>produces predictions</high> from a model. Simply put model object as the first argument. ```r # Get fitted values glm_fits <- predict(object = income_mod) glm_fits[1:8] ``` ``` 1 2 3 4 5 6 7 8 5508 6960 6982 8645 5325 10648 8663 4592 ``` ] .pull-right45[  ] --- # `postResample()` .pull-left45[ The `postResample()` function <high>gives a simple summary</high> of a models' performance in a <high>regression task</high>. Simply put the predicted values and the true values inside the function. ```r # evaluate postResample(glm_fits, baselers$income) ``` ``` RMSE Rsquared MAE 1173.079 0.821 937.113 ``` ] .pull-right45[  ] --- .pull-left5[

 ## `confusionMatrix()`

 The `confusionMatrix()` does the same for a models' performance in a <high>classification task</high>. Simply put the predicted values and the true values inside the function. ```r # eyecor to factor baselers$eyecor <- factor(baselers$eyecor) # run glm model for classification eyecor_mod <- train(form = eyecor ~ age + height, data = baselers, method = "glm", trControl = ctrl) # evaluate confusionMatrix(predict(eyecor_mod), baselers$eyecor) ``` ] .pull-right4[
 ``` Confusion Matrix and Statistics Reference Prediction no yes no 0 0 yes 353 647 Accuracy : 0.647 95% CI : (0.616, 0.677) No Information Rate : 0.647 P-Value [Acc > NIR] : 0.514 Kappa : 0 Mcnemar's Test P-Value : <2e-16 Sensitivity : 0.000 Specificity : 1.000 Pos Pred Value : NaN Neg Pred Value : 0.647 Prevalence : 0.353 Detection Rate : 0.000 Detection Prevalence : 0.000 Balanced Accuracy : 0.500 'Positive' Class : no ``` ] --- class: middle, center
Practical