NOTE: Any manual changes to Github Wiki will be overwritten by push (PR merged) to master
branch
These files should updated whenever we merge to master, and be in sync between:
- The README files in the repo,
- The Github Wiki, and
- The generated doc site served when running the server and on github pages
This project uses a Github Action to accomplish this. The action is executed on merge to the master
branch
and defined inside of the ./.github/workflows/
directory(github)
(along with all other github actions) that creates a commit to update the docs directory on github and then
calls a script in the scripts/actions
directory(github).
The script retrieves the following markdown files (defined in ./.esdoc.json
) and copies them to a temporary
directory, then uses the wiki-page-creator-action
to update the Github wiki.
Table of Contents
- Setup - dependencies and how to install and start development (eventually production?)
- Entry - How Javascript Bundles are defined and files that can be included
- HTML - How HTML files are created and the processes we use to ensure quality
- CSS - CSS Normalization, Processing and Frameworks
- Images - Including images and SVG icons from free library
- Helpers - Javascript Helper Classes and Code that is used in the project
- Static HTML Components - HTML Components that are generated during the build process
- Dynamic HTML Components - HTML/JS Components that are created with Handlebars dynamically during runtimes
- Github Actions - Notes about Actions run on to ensure quality
- Testing - How testing is configured and how to run tests
- Custom Webpack Loaders - Explaining how we configure webpack loaders to generate the application
.
Setup
Requires Node 12+ to build. Please install this before attempting to build. The easiest way to install and manage node versions is by using the Node Version Manager. We define a .nvm file in the project to help reference this minimum node version.
Use nvm use 12
to switch node versions after installing a new Node version. Then you should install all
project dependencies(github)
with npm install -D
. This should install Webpack and all the libraries/plugins used in this project.
If you have cloned the master branch, then the build should compile and all tests should pass once the
dependencies have been downloaded and installed. To only compile the html and javascript, use npm run build
, or you can run the tests with npm run test
. To watch the files for changes and rebuild/retest the files
on changes, you can use npm run start-watch
. See the package.json(github)
for all possibe npm commands.
Webpack
Webpack config file(github) is used to manage webpack build to compile the application.
This file:
- Defines the Entrypoint javascript files to create bundles
- Defines where the generated files are placed
- Defines how to import other files
- Sets up Modules/Plugins:
- Babel and ESLint Loaders
- Flow Integration with Webpack
- Reference HTML Files (source and destinations) and javascript bundles to include on pages
- PostCSS Loader for easy CSS files
- Hot Module Replacement for rebuilding on file changes
- Custom Script to run at end of webpack build that Lints generated HTML files
- Sets up Development Server to Host HTML/JS/CSS Files for rapid development
Dev Server
During development (while using the npm run start-watch
command), a Webpack Dev Server is instantiated to host
the generated WebApp files. The Dev Server is manually instantiated in the webpack.config.js file because
the scripts actually start Karma to watch and manage the test runs, which then runs the Webpack config file to
start the build process and this Dev Server.
Documentation
The docs/
directory is created with npm run doc
, this generates an esdoc webpage based on the modified
template stored in docs/template
from the README files in the repo. These docs are also synced with the Github
wiki page via a Github Action (see Github Actions/Scripts page for more details.
The Dependency Graph is created with Madge and graphviz, you will need to
install both in order to update the dependency graph. Didn't include these in the package.json dependencies
because this is more than is needed to develop a working app or even write basic documentation. This is split
out to a separate npm script: npm run doc-image
so it can be run when someone actually installs the dependencies
Install madge with npm install -g madge
and install graphviz with brew install graphviz
or
port install graphviz
(for OSX). Then run npm run doc-image
in the repo and add the created image from
docs/image/dependency.png
and commit to update the docsite.
Javascript Entry Points
The webpack.config.js
(github)
defines entry points for javascript bundles that can be created for each page, or can be optimized to bundle
code that can be cached separately, loaded asynchronously or lazy loaded, after the page has loaded and rendered.
These bundles are separately included on each HTML page (defined with the HTMLWebpackPlugin
in the Webpack
config) and will execute in the order they are included on the webpage. The files in these bundles are separate
modules and self-contained, so any variables will only be available within that module context. However, any
items declared at the global level in a bundle (e.g.global.property = 'value';
) will be available in any other
bundle that is on that HTML page, as well..
Importing Files
The javascript file that is referenced as an entry point, can import other files and/or libraries using either
CommonJS Module syntax (e.g. const package = require('module')
) or using ECMA6(ES2015) syntax (e.g. import
package from 'lib'
). These files will then be included in the generated bundle for that entry point.
The file types available to import are defined in the rules
section of the Webpack config:
- Javascript (.js) Files
- CSS (.css) Files
- Images (.png/.svg/.jp(e)g/gif) Files
Entry Notes/Ideas
- [ ] Fonts
HTML
HTML files structure the layout of the web application. The final HTML files are generated by webpack and
output to the public/
directory when building with npm run build
and define the pages that can be accessed via browser in the final application.
Webpack
The webpack.config.js file(github)
defines the HTML pages that will be generated by the build process. For each instance of the HtmlWebpackPlugin
in the plugins
section, webpack will output a new HTML file using the template
at the filename
provided
(inside of public/
).
Page Header Meta Attributes
The <meta>
webpage attributes are passed into the instance of the HtmlWebpackPlugin for each page defined in
the webpack config file. These attributes could be dynamically set for each page if desired, or can be the same
for each html page (as they are currently) and imported from a json file(github)
Templating
Static
Simple Static HTML Templating can be done with the underscore-lodash-loader.
This loader allow HTML files to be imported during the compilation process using @require
or @import
in the HTML files, and also enables variables that can be replaced when the HTML is generated (e.g. <%=
name %>
) will be replaced if we use @import(<file_name>, { name: "Devlin Junker" })
with Devlin Junker
.
Dynamic Javascript Components (Handlebars)
More complicated components (especially those that require javascript or looping/conditional statements
should be written with handlebars in the components/
directory.
If the component should respond to user interactions and events, the component should have a .hbs
file
and an index.js
file containing a function, that imports the .hbs
file and compiles it with the
parameters and handlers passed in.
Other, less complex components can be written purely in .hbs
files with helpers and partials.
HTML Linting
During the build process, webpack is configured to lint the final HTML files after each successful build with htmlhint to spot any errors in the HTML structure. This will cause an error in the build process output. You can see the rules defined in the .htmlhintrc file (github).
These include:
- Requiring Doctype
- Disabling Inline CSS Styles on elements
- Attribute naming conventions
- Requiring some accessibility attributes
HTML Notes/Ideas
- [x] Templating
- [ ] Accessibility Linting
- [ ] UI Framework?
CSS
CSS defines the look and feel of the application, giving style to the HTML elements on the page. This project uses a couple of tools during the build process to ensure quality CSS code with some of the most recent improvements to the CSS ecosystem.
The project can parse and import either .scss
or .css
files via javascript module imports, the .scss
file ending is used so IDEs have an easier time with syntax highlighting.
Tailwind CSS Framework (Utility First)
Tailwind is included in this project to style the application. Tailwind is a composable, utility-first css framework. This is a shift from the "semantic" based css conventions where classes/styles are defined around a name that has meaning in the application domain. In this way of thinking, css classes define a consistent look and feel of the application. These utility classes are then applied to the elements in each html file to create a consistent style across the application that is not predefined.
Tailwind is built on top of normalize.css to standardize the look and feel of the application across multiple browsers and clear any default styles.
Tailwind's colors/padding/etc is customizable via the theme in the tailwind.config.js
Review these screencasts and other resources for more information. Visit the docs for configuration and notes on each rule as well as some example components
Mini CSS Extract Plugin
The webpack config file(github)
imports the mini-css-extract-plugin
and loader to extract all css styles that have been imported into the
javascript bundles created by webpack. This enables the stylesheets to be referenced in the HTML file
separately, so they can be linked at the top of the page and loaded first and also so they can be cached in
the browser to speed up page load.
PostCSS
PostCSS is a javascript tool that parses and transforms the CSS files. The webpack
config contains a reference to the postcss-loader
so that css files can be generated during the
build process from css files that are referenced in the codebase. The postcss.config.js file(github)
defines the plugins that we use during the PostCSS parsing and generation process.
PreCSS and PostCSS-Preset-Env
PreCSS enables SASS like features in the css files including variables and nesting selectors generating the proper definition in the final CSS file. The PostCSS-Preset-Env plugin enables many new CSS features listed at the link provided.
Stylelint
Stylelint is used to validate the css file uses proper syntax. The rules for this project
are defined in the .stylelintrc
file (github). The rules extend the
Standard Stylelint Config,
and additional rules can be added to this config file.
See list of all rules: here
See list of suggested Additions: here
Autoprefixer
Autoprefixer is used to help keep the css files clean by automatically adding browser/vendor prefixes to css rules.
List Selectors
List Selectors is a plugin that we use to generate a json file containing the css selectors that are processed by PostCSS.
- [ ] Show output selectors, not input
- [ ] Map of selectors to css rules?
CSS Notes/Ideas
- Guidelines: https://cssguidelin.es/
- IDEA: During development (
npm run start-watch
) css is included in JS bundles for faster build- only extract during production to improve the look and feel of app loading
- [ ] BEM Linting?
- [ ] Styleguide
- [ ] Framework Demos (Separate Repo?)
- MVP (Product/Business) Style: https://andybrewer.github.io/mvp/
- remember this for the future if need a splash screen for company/product/webapp
Images
All images for the web application should be stored in the img/
directory. An alias is configured in the
webpack.config.js file (github)
to enable requiring images with require("img/<path_in_img_dir")
or referencing in .html or .hbs files
src
property.
Icons
This template includes Zondicons, a free SVG icon library with 270 icons.
These can be included in the HTML template files with @svg(<img/<path_to_svg_relative_to_img>)
and the svg file
will be included inline so standard utility classes from Tailwind can be applied.
It is best to wrap the icons in a wrapper containing the icon
class, as this will default to the icon being
the size and color of the font.
Image Notes/Ideas
- [ ] Icon page in docs that shows all icons and their paths for including in partials
Helpers
This project contains a helpers/
directory(github)
that holds Javascript classes and methods that can be used across multiple projects and entry points with
reusable methods and commonly used logic.
Helper Examples
Notes on the Example Helper class and methods in this project:
LocalStorage Helper
The localstorage helper (github) contains methods for saving/retrieving values with the browser localstorage API. Values saved with this will be stored on the clients browser and can be retreived when they return to the web application (until they clear their browser localstorage/data).
Relative Href Helper
The Relative Href helper(github)
contains a small snippet of code that must be included in each javascript entry point. This code sets the
<base>
tag inside of the
element in the HTML page to tell relative links on the page the href
that
they should be relative to.
i.e. if <base href='http://test.com/'>
exists at the top of the page, all relative
links (e.g. ...
) will direct to http://test.com/example
(where example is any relative
href
value). This is compared to the regular relative link behavior where the link is relative to the current
page (value in the browser url bar).
Handlebars Helpers
Handlebars is the simple HTML templating framework this project uses to create HTML components. Handlebars
lets the project import it's own helpers in the webpack.config.js
(github)
that can add additional functionality and logic to the template partial files easily.
Default Value Helper
Helper that checks a variable to see if it contains a value and returns that value if it does, or else it returns a default value (2nd parameter).
e.g. will output '123' unless testVar
contains a value, in which case it will return the value in testVar
// .hbs
{{default-val testVar '123'}}
let context = { }
// Output
123
let context = { testVar: 'abc' }
// Output after
abc
Eq Helper
Helper that compares to variables and checks if they are equal with ===
. Returns true
or false
. This is
best used inside of an expression in an #if
block helper.
e.g. (will display Hello World!
on page if context variable var
=== 'true')
// .hbs file
{{#if (eq var 'true')}} Hello World! {{/if}}
let context = { var: true };
// Output
Hello World!
let context = { var: false };
// Output
Helper Notes/Ideas
- [ ] Configuration file
- [ ] Performance Logger
- [ ] API Helpers (Internal vs External?)
Static HTML Components
Some parts of the interface can be generated during the build process to reduce processing on the client side
and speed up page generation if the assets are not dynamic in relation to the user. These components are
generated using underscore-template-loader and can be
included in the entry .html
pages or .hbs
files with @require(<path_to_static_file>, args)
with optional
arguments
Custom Macros
Custom macros can be created that execute some function during the build process. This project has example custom
macros that include the build details and repository information in the output HTML pages. These macros are included
in the webpack.config.js(github)
configurations for the underscore-template-loader. These macros are given names in the webpack config file and
then accessed using the @
symbol (e.g. @year()
).
Static Component Examples
A couple of notes on static component examples included in this project:
Header
Contains links to the different part of the application, this is a good example of being dynamic (but not relative to the user) but still being able to be compiled during the build process.
Footer
Contains reference to the project details and build details for developers. This could also include:
- contact information
- donation links
- other navigation component or site tree.
Static Partial Notes/Ideas
- [ ] Move macros out of webpack.config.js into their own file (in src/static/ ?)
Dynamic HTML Components
Dynamic Components can be created with Handlebars partials and javascript files to add event handlers that toggle properties, trigger backend calls and re-render the DOM in the browser.
Partials
Handlebars partials are included either:
- in other partial files with
{{> <partial_name> (arg_name=arg_value..) }}
syntax - in javascript files by:
- importing at top of file using relative path e.g.
import template from ./example.partial.hbs
- compiling and capturing string in variable e.g.
const strTemp = template(<context>)
- context is object where properties become variables in partial file template
- importing at top of file using relative path e.g.
Javascript Files
To attach event handlers to the HTML created by handlebars, you'll need to add the templateString generated by the Handlebars method to the DOM. and then attach event handlers to the elements created.
e.g.
const template = require("<path_to_hbs_file>");
const context = { .. };
const strTemp = template(context, options?);
const container = document.getElementById("<container_id>");
container.innerHTML = strTemp;
container.querySelector("<interactive_element_selector>").onclick = () => { // Do stuff };
Dynamic Component Examples
A couple of notes on the Dynamic Component examples in this project.
Checkbox
Partial component with svg checkmark inside of checkbox. This can be used to add a stylized checkbox to the page rather than the standard checkbox created by the browser.
- id - (default: undefined) only if set will add
id
andname
attributes to <input> with this value - val - (default: true) sets the value of the <input> checkbox
- checked - (default: false) sets checked status of checkbox
- label - (default: '') clickable label text (toggles checkbox)
- color - (default: 'black') color of the checkmark in the checkbox
- bg - (default: 'white') background color of the checkbox
- bg-checked - (default: bg || 'white') background color of the checkbox after checked
- size - (default: '') size of checkmark (available values =
sm
,lg
)
e.g.
/* `.hbs` file */

{{> form/checkbox checked=complete color='white' bg='black' bg-checked='gray-200' label='Check Me' size='sm'}}

/* `.js` file */
document.querySelector('#checkbox-1 input').onchange = () => {
// Do stuff
}
Note: Event handlers are attached in the javascript file to trigger this actually doing anything on the page
List Object and List item
Handlebars partials to render lists of items
inside of html elements. The developer can specify a template
partial that can be used to generate the contents of the list item (this should be a .hbs file).
Because this is a more complicated object (with content template) and likely requires event handlers for user interaction, it is best to create the ListObject inside of the javascript files and add it to the DOM from there.
e.g.
// Import from path to component
import listObjectTemplate from '../components/list/list-object.hbs';
// Build HTML from Template method
const listObject = listObjectTemplate({ items, template: 'my-list-template' }, {
partials: {
'my-list-template': listItemTemplate
}
});
// Append HTML to Page
document.getElementById('page').innerHTML = listObject;
// Add event handlers...
listObject.querySelectorAll(<selector_of_element_with_event>).onclick = () => {
// do stuff
};
Components Notes/Ideas
- Seems like handlbars isn't great by itself for interactive applications
- Handlebars recommends some frameworks: https://github.com/devlinjunker/template.webpack.fend/pull/23#issuecomment-629585403
- Reactive-Handlebars looks interesting, but hasn't been updated in years...
- Can we add helpers that attach event handlers via some template context variable and a property on the element?
- how about a class? constructor with params that associate class names with event handlers?
- base class that creates DOM elements (with
render
function?) using:const temp = document.createElement('div'); temp.innerHTML = template(context); return temp.innerHTML;
- base class that creates DOM elements (with
- this is almost like recreating frameworks like these though (should test before we roll our own):
- Angular
- Aurelia
- Ember
- Inferno
- Mithril
- Svelte
- Ractive
- React
- Vue
- how about a class? constructor with params that associate class names with event handlers?
- Backbone?
Actions and Githooks
This project uses github actions(github) to enforce actions/checks and workflow processes on github.
On Merge to Master
Whenever a PR is merged master, the documentation is updated based on the changes the user made in the commits. A git action(github) is set up to do the following:
- Collect README files and update wiki
- Fix/remove links in Wiki
- Build documentation and generate commit
This Action requires the Git repo to have a secret configured in the Settings page named GH_PAT
that
contains a Github Personal Access Token from your user account: https://github.com/settings/tokens.
There is also a reference to the repo name in the script, so you will need to ensure that this is updated if
the repo name is different.
Master Build Status
This action checks the build status of the project and verifies that all of the tests and style linters are
not failing.
Runs:
- linter
- build (with webpack)
- tests (karma)
Githooks
TODO...
Github Specific
Whenever a PR is made on Github, the body/description will be pre-populated with the contents in
.github/PULL_REQUEST_TEMPLATE.md
Testing
You can run a single run of all unit tests in the application with npm run test
. Or the tests will be run
after the compilation has finished when running npm run start-watch
. The testing is managed by
Karma and configured using the karma.conf.js
file(github)
This config file defines:
- the testing framework we use (mocha)
- the test bootstrap entry point(github)
- The browser launchers that we use to run the Unit Tests (chrome)
- The log level to display
- Imports webpack config so we can also run the test and dev server if we use
npm run start-watch
Bootstrap File
The testing bootstrap file(github) finds all of the test files and imports global objects that can be used in all tests to simplify each test file. It also creates a sinon Sandbox that is reset before each test for mocking/stubbing services and non-tested functions in the test context.
Global Variables (available in all .spec
files):
Test Notes/Ideas
- [ ] Cypress UI
- [ ] Mock API requests?
Webpack Loaders
Webpack Loaders are used during the webpack build process to transpile the javascript and other asset types defined in the webpack.config.js(github).
Standard Loaders
This project uses basic loaders for most file types:
- babel-loader and eslint-loader for javascript files
- MiniCssExtractPlugin Loader, css-loader and postcss-loader for
.css
or.scss
files - file-loader to include image files with html-webpack-plugin
- svg-inline-loader for svg files (used in html-webpack-plugin)
- underscore-template-loader for processing html files
Custom Loader Example
This project also includes one custom loader(github)
to help generate handlebars template files. This is part of processing .hbs
and .html
files.
- First we run the
.hbs
or.html file through the custom
svg-icon-loaderwhich replaces
@svg` imports with the contents of the svg file referenced (inlining the contents from svg files) - The function is then run through the next loader in the pipeline (defined in webpack.config.js)
- handlebars-loader to return the handlebars template that is used to create the
template()
function that is imported when you require a.hbs
file in the javascript code. - underscore-template-loader to generate the html entry file
- handlebars-loader to return the handlebars template that is used to create the
Notes/Ideas
- [x]
Why are svg files included in output directory? they should be inlined I thoughtnot happening anymore


| 009:065 Khan | : |
If you ask them (about this), they declare: "We were only talking idly and joking." Say: "Was it at Allah (swt), and His Ayat (proofs, evidences, verses, lessons, signs, revelations, etc.) and His Messenger (SAW) that you were mocking?" |
| 009:065 Maulana | : |
And if thou ask them, they would certainly say: We were only talking idly and sporting. Say: Was it Allah and His messages and His Messenger that you mocked? |
| 009:065 Pickthal | : |
And if thou ask them (O Muhammad) they will say: We did but talk and jest. Say: Was it at Allah and His revelations and His messenger that ye did scoff? |
| 009:065 Rashad | : |
If you ask them, they would say, "We were only mocking and kidding." Say, "Do you realize that you are mocking GOD, and His revelations, and His messenger?" |
| 009:065 Sarwar | : |
If you question them about their manners, they say, "We were only arguing for the sake of amusement."  |
| 009:065 Shakir | : |
And if you should question them, they would certainly say: We were only idly discoursing and sporting. Say: Was it at Allah and His communications and His Messenger that you mocked? |
| 009:065 Sherali | : |
And if thou question them, they will most surely say, 'We were only talking idly and jesting.' Say, 'Was it ALLAH and HIS Signs and HIS Messenger that you mocked at?' |
| 009:065 Yusufali | : |
If thou dost question them, they declare (with emphasis): "We were only talking idly and in play." Say: "Was it at Allah, and His Signs, and His Messenger, that ye were mocking?" |
Concepts/Themes Covered: الإيمان > الإيمان بالله > النفاق Faith> Belief In Allah> Hypocrisy الجهاد > الغزوات > غزوة تبوك Jihad> The Holy Battles> Tabuk Battle الإنسان والعلاقات الأخلاقية > الأخلاق الذميمة > السخرية Man and The Moral Relations>The Dispraised Morals>Sarcasm
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


|
LFP Classification
1.0
Automatic classification of LFP signals using Deep Neural Networks
|
Functions | |
| def | mlp (layers, units_per_layer, dropout=None) |
| Defines a classical neural network sometimes called: Multi-Layer Perceptron. More... | |
| def | cnn (inputs, units_per_layer, dropout) |
| Creates a model of a Convolutional Neural Network with a Conv1D as the input layer, one dense as the only hidden layer and another dense with only 1 neuron as the output layer. More... | |
| def | lstm (units_per_layer, dropout) |
| Creates a model of a Long Short-Term Memory Neural Network as the input layer, one dense with only 1 neuron as the output layer. More... | |
| def | compile_and_fit (model, train, val, epochs=20, patience=2) |
| Fits the provided training data in the specified model and train's it. More... | |
| def models.cnn | ( | inputs, | |
| units_per_layer, | |||
| dropout | |||
| ) |
Creates a model of a Convolutional Neural Network with a Conv1D as the input layer, one dense as the only hidden layer and another dense with only 1 neuron as the output layer.
The first two layer has ReLU activation and the last one uses a linear activation function.S
| inputs | Number of inputs of the network. It is used as the kernel size with the intention that the 1D convolutional layer outputs a single value throughout the specified number of filters. |
| units_per_layer | Specified the number of neurons of the hidden dense layer, which has to match with the number of filters that will output a result in the 1D convolutional input layer. |
| dropout | A value between 0 and 1 of neuron's results to discard of the training. This regularization method will be added to the model as a layer the output layer. |
Definition at line 66 of file models.py.
Referenced by Predictor.predictor().
| def models.compile_and_fit | ( | model, | |
| train, | |||
| val, | |||
epochs = 20 , |
|||
patience = 2 |
|||
| ) |
Fits the provided training data in the specified model and train's it.
The validation data is used to compare the performance of the model against unknown data. MSE is used as the cost function to train the model and MAE as the performance evaluation metric.
| model | Model to train. It can be a MLP, CNN or LSTM, among others. |
| train | The dataset for training the model. Must have the shape: (batch, time, features) |
| val | The dataset for validating the model. Must have the shape: (batch, time, features) |
| epochs | Number of iteration over the entire set of data (all the batches). |
| patience | Number of epochs to wait for improvement in the metrics. If there is no notorious improvement in the performance of the validation set after the 'patience' epochs, the training will stop at this point. |
Definition at line 116 of file models.py.
Referenced by Predictor.predictor().
| def models.lstm | ( | units_per_layer, | |
| dropout | |||
| ) |
Creates a model of a Long Short-Term Memory Neural Network as the input layer, one dense with only 1 neuron as the output layer.
The activation functions of the LSTM layer are the regular ones for each of it's gates.
| units_per_layer | Number of inputs of the network. |
| dropout | A value between 0 and 1 of neuron's results to discard of the training. If provided,this regularization method will be to the LSTM Layer. |
Definition at line 89 of file models.py.
Referenced by Predictor.predictor().
| def models.mlp | ( | layers, | |
| units_per_layer, | |||
dropout = None |
|||
| ) |
Defines a classical neural network sometimes called: Multi-Layer Perceptron.
It is Feedforward and fully-connected, with the specified parameters. The activation function of the hidden layers is ReLU, and the activation of the output is linear.
| layers | Number of hidden layers (besides the input and outputs ones). |
| units_per_layer | Number of neurons per layer. Applies to all layers except for the last one which has only 1: the predicted angle. |
| dropout | A value between 0 and 1 of neuron's results to discard of the training. This regularization method will be added to the model. One after the input layer and one before the output layer. |
Definition at line 32 of file models.py.
Referenced by Predictor.predictor().


What is "course virtualization" and why should I care?
Adopting virtual machines in my course has eliminated the need to give personalized support in getting the required software installed and running. Not only is this a great relief personally, it also allows the course to move forward much faster and the reception among students has been very positive.
Overview
Despite computer programming courses today often having hundreds of participants, it is important that the students complete practical programming exercises and have a possibility to participate in hands-on programming sessions, where they can get help from their peers and teaching assistants. However, heterogeneous devices used by students pose a great challenge. When installing and using development tools, both platform specific issues and the limitations of students’ personal skill cause issues and lots of extra work for teachers. To address these challenges, we built a virtualized environment that provides the same homogeneous environment for all the students, reducing the time used for configuration and assisting students and allowing time to be used teaching the actual contents of the course.
A hypervisor is a program that emulates a computer.What is a hypervisor?
Benefits of Virtualization
Installation of a hypervisor is considerably simpler than installing and configuring large sets of development tools. Instead of every student installing and configuring all of the software needed on a course, possibly needing lecturer or peer assistance, students can install a hypervisor and run a virtual machine that already has the software pre-installed. This greatly reduces the time and resources used for course and assignment preparations and enables the time to be used for actual course activities instead. The approach also has several other positive effects:
- The teacher has comprehensive knowledge of the environment that students have at their disposal, making it significantly easier to provide technical support. Compared to the case of multiple platforms, the VM reduces most issues to a single problem of starting the hypervisor for the first time.
- The teacher can customize the virtual machine before distributing it to the students. Quick changes to the machines are easily possible if needed.
- A student can have several different VMs simultaneously, each serving the needs of a different course. Isolating different course VMs eliminates issues that might result in conflicting versions or configurations. The design also isolates the student's personal system from potentially harmful, but educationally insightful experiments in the development environment.
- The same process and VM model can be used across several different courses, unifying some of the technical support needs of students. The same unified environment also quickly becomes familiar when used on multiple courses.
Eget magna fermentum iaculis eu non diam phasellus. Elementum pulvinar etiam non quam lacus suspendisse faucibus interdum. Nulla porttitor massa id neque aliquam vestibulum morbi blandit cursus. Velit aliquet sagittis id consectetur purus ut faucibus. Vivamus at augue eget arcu dictum varius duis at. Quis blandit turpis cursus in hac habitasse platea. Condimentum lacinia quis vel eros donec. Egestas sed tempus urna et pharetra pharetra massa massa. Nunc aliquet bibendum enim facilisis gravida neque convallis. Hac habitasse platea dictumst vestibulum rhoncus est pellentesque. Tempor orci eu lobortis elementum nibh.
Known Limitations
Nisi est sit amet facilisis magna etiam tempor. Blandit massa enim nec dui nunc. Habitant morbi tristique senectus et netus et malesuada fames. Nunc scelerisque viverra mauris in aliquam sem. Ut etiam sit amet nisl purus in. Blandit massa enim nec dui nunc mattis enim. Tellus rutrum tellus pellentesque eu tincidunt tortor aliquam nulla facilisi. Dapibus ultrices in iaculis nunc sed augue lacus viverra. Quam adipiscing vitae proin sagittis nisl rhoncus. Porttitor eget dolor morbi non arcu risus quis varius. Id porta nibh venenatis cras sed felis eget velit aliquet. Vulputate dignissim suspendisse in est ante. Fringilla urna porttitor rhoncus dolor purus non enim praesent.


Student Corner
Projects
Students
Login
Enable Editing
Browser not supported
Created by
Robert Frost
,
Jackson Smith
, and
Alex Grey


pyemu.mat package¶
Submodules¶
pyemu.mat.mat_handler module¶
Matrix, Jco and Cov classes for easy linear algebra
-
pyemu.mat.mat_handler.
save_coo
(x, row_names, col_names, filename, chunk=None)[source]¶ write a PEST-compatible binary file. The data format is [int,int,float] for i,j,value. It is autodetected during the read with Matrix.from_binary().
Parameters: - x (numpy.sparse) – coo sparse matrix
- row_names (list) – list of row_names
- col_names (list) – list of col_names
- filename (str) – filename to save binary file
- droptol (float) – absolute value tolerance to make values smaller than zero. Default is None
- chunk (int) – number of elements to write in a single pass. Default is None
-
pyemu.mat.mat_handler.
concat
(mats)[source]¶ Concatenate Matrix objects. Tries either axis.
Parameters: mats (list) – list of Matrix objects Returns: Matrix Return type: Matrix
-
pyemu.mat.mat_handler.
get_common_elements
(list1, list2)[source]¶ - find the common elements in two lists. used to support auto align
- might be faster with sets
Parameters: - list1 (list) – a list of objects
- list2 (list) – a list of objects
Returns: list – list of common objects shared by list1 and list2
Return type: list
-
class
pyemu.mat.mat_handler.
Matrix
(x=None, row_names=[], col_names=[], isdiagonal=False, autoalign=True)[source]¶ Bases:
object
a class for easy linear algebra
Parameters: - x (numpy.ndarray) – Matrix entries
- row_names (list) – list of row names
- col_names (list) – list of column names
- isdigonal (bool) – to determine if the Matrix is diagonal
- autoalign (bool) – used to control the autoalignment of Matrix objects during linear algebra operations
Returns: Matrix
Return type: -
binary_header_dt
¶ numpy.dtype – the header info in the PEST binary file type
-
binary_rec_dt
¶ numpy.dtype – the record info in the PEST binary file type
-
to_ascii : write a PEST-style ASCII matrix format file
-
to_binary : write a PEST-stle compressed binary format file
Note
this class makes heavy use of property decorators to encapsulate private attributes
-
integer
¶ alias of
numpy.int32
-
double
¶ alias of
numpy.float64
-
char
¶ alias of
numpy.uint8
-
binary_header_dt
= dtype([('itemp1', '<i4'), ('itemp2', '<i4'), ('icount', '<i4')])
-
binary_rec_dt
= dtype([('j', '<i4'), ('dtemp', '<f8')])
-
coo_rec_dt
= dtype([('i', '<i4'), ('j', '<i4'), ('dtemp', '<f8')])¶
-
par_length
= 12¶
-
obs_length
= 20¶
-
new_par_length
= 100¶
-
new_obs_length
= 100¶
-
reset_x
(x, copy=True)[source]¶ reset self.__x private attribute
Parameters: - x (numpy.ndarray) –
- copy (bool) – flag to make a copy of ‘x’. Defaule is True
Note
makes a copy of ‘x’ argument
-
hadamard_product
(other)[source]¶ Overload of numpy.ndarray.__mult__(): element-wise multiplication. Tries to speedup by checking for scalars of diagonal matrices on either side of operator
Parameters: other (scalar,numpy.ndarray,Matrix object) – the thing for element-wise multiplication Returns: Matrix Return type: Matrix
-
mult_isaligned
(other)[source]¶ check if matrices are aligned for dot product multiplication
Parameters: other ((Matrix)) – Returns: bool – True if aligned, False if not aligned Return type: bool
-
element_isaligned
(other)[source]¶ check if matrices are aligned for element-wise operations
Parameters: other (Matrix) – Returns: bool – True if aligned, False if not aligned Return type: bool
-
newx
¶ return a copy of x
Returns: numpy.ndarray Return type: numpy.ndarray
-
x
¶ return a reference to x
Returns: numpy.ndarray Return type: numpy.ndarray
-
as_2d
¶ get a 2D representation of x. If not self.isdiagonal, simply return reference to self.x, otherwise, constructs and returns a 2D, diagonal ndarray
Returns: numpy.ndarray Return type: numpy.ndarray
-
shape
¶ get the implied, 2D shape of self
Returns: tuple – length 2 tuple of ints Return type: tuple
-
ncol
¶ length of second dimension
Returns: int – number of columns Return type: int
-
nrow
¶ length of first dimensions
Returns: int – number of rows Return type: int
-
T
¶ wrapper function for Matrix.transpose() method
-
get_maxsing
(eigthresh=1e-05)[source]¶ Get the number of singular components with a singular value ratio greater than or equal to eigthresh
Parameters: eigthresh (float) – the ratio of the largest to smallest singular value Returns: int – number of singular components Return type: int
-
pseudo_inv_components
(maxsing=None, eigthresh=1e-05)[source]¶ Get the truncated SVD components
Parameters: - maxsing (int) – the number of singular components to use. If None, maxsing is calculated using Matrix.get_maxsing() and eigthresh
- eigthresh (float) – the ratio of largest to smallest singular components to use for truncation. Ignored if maxsing is not None
Returns: - u (Matrix) – truncated left singular vectors
- s (Matrix) – truncated singular value matrix
- v (Matrix) – truncated right singular vectors
-
pseudo_inv
(maxsing=None, eigthresh=1e-05)[source]¶ The pseudo inverse of self. Formed using truncated singular value decomposition and Matrix.pseudo_inv_components
Parameters: - maxsing (int) – the number of singular components to use. If None, maxsing is calculated using Matrix.get_maxsing() and eigthresh
- eigthresh (float) – the ratio of largest to smallest singular components to use for truncation. Ignored if maxsing is not None
Returns: Matrix
Return type:
-
indices
(names, axis=None)[source]¶ - get the row and col indices of names. If axis is None, two ndarrays
- are returned, corresponding the indices of names for each axis
Parameters: - names (iterable) – column and/or row names
- axis ((int) (optional)) – the axis to search.
Returns: numpy.ndarray – indices of names.
Return type: numpy.ndarray
-
old_indices
(names, axis=None)[source]¶ - get the row and col indices of names. If axis is None, two ndarrays
- are returned, corresponding the indices of names for each axis
Parameters: - names (iterable) – column and/or row names
- axis ((int) (optional)) – the axis to search.
Returns: numpy.ndarray – indices of names.
Return type: numpy.ndarray
-
align
(names, axis=None)[source]¶ reorder self by names. If axis is None, reorder both indices
Parameters: - names (iterable) – names in rowS andor columnS
- axis ((int)) – the axis to reorder. if None, reorder both axes
-
get
(row_names=None, col_names=None, drop=False)[source]¶ get a new Matrix instance ordered on row_names or col_names
Parameters: - row_names (iterable) – row_names for new Matrix
- col_names (iterable) – col_names for new Matrix
- drop (bool) – flag to remove row_names and/or col_names
Returns: Matrix
Return type:
-
drop
(names, axis)[source]¶ drop elements from self in place
Parameters: - names (iterable) – names to drop
- axis ((int)) – the axis to drop from. must be in [0,1]
-
extract
(row_names=None, col_names=None)[source]¶ wrapper method that Matrix.gets() then Matrix.drops() elements. one of row_names or col_names must be not None.
Parameters: - row_names (iterable) – row names to extract
- col_names ((enumerate)) – col_names to extract
Returns: Matrix
Return type:
-
get_diagonal_vector
(col_name='diag')[source]¶ Get a new Matrix instance that is the diagonal of self. The shape of the new matrix is (self.shape[0],1). Self must be square
Parameters: col_name – str the name of the column in the new Matrix Returns: Matrix Return type: Matrix
-
to_coo
(filename, droptol=None, chunk=None)[source]¶ write a PEST-compatible binary file. The data format is [int,int,float] for i,j,value. It is autodetected during the read with Matrix.from_binary().
Parameters: - filename (str) – filename to save binary file
- droptol (float) – absolute value tolerance to make values smaller than zero. Default is None
- chunk (int) – number of elements to write in a single pass. Default is None
-
to_binary
(filename, droptol=None, chunk=None)[source]¶ write a PEST-compatible binary file. The format is the same as the format used to storage a PEST Jacobian matrix
Parameters: - filename (str) – filename to save binary file
- droptol (float) – absolute value tolerance to make values smaller than zero. Default is None
- chunk (int) – number of elements to write in a single pass. Default is None
-
classmethod
from_binary
(filename)[source]¶ class method load from PEST-compatible binary file into a Matrix instance
Parameters: filename (str) – filename to read Returns: Matrix Return type: Matrix
-
classmethod
from_fortranfile
(filename)[source]¶ - a binary load method to accommodate one of the many
- bizarre fortran binary writing formats
Parameters: filename (str) – name of the binary matrix file Returns: Matrix Return type: Matrix
-
to_ascii
(out_filename, icode=2)[source]¶ write a PEST-compatible ASCII Matrix/vector file
Parameters: - out_filename (str) – output filename
- icode ((int)) – PEST-style info code for Matrix style
-
classmethod
from_ascii
(filename)[source]¶ load a pest-compatible ASCII Matrix/vector file into a Matrix instance
Parameters: filename (str) – name of the file to read
-
classmethod
from_dataframe
(df)[source]¶ - class method to create a new Matrix instance from a
- pandas.DataFrame
Parameters: df (pandas.DataFrame) – Returns: Matrix Return type: Matrix
-
classmethod
from_names
(row_names, col_names, isdiagonal=False, autoalign=True, random=False)[source]¶ class method to create a new Matrix instance from row names and column names, filled with trash
Parameters: - row_names (iterable) – row names for the new matrix
- col_names (iterable) – col_names for the new matrix
- isdiagonal (bool) – flag for diagonal matrix. Default is False
- autoalign (bool) – flag for autoaligning new matrix during linear algebra calcs. Default is True
- random (bool) – flag for contents of the trash matrix. If True, fill with random numbers, if False, fill with zeros Default is False
Returns: mat – the new Matrix instance
Return type:
-
to_dataframe
()[source]¶ return a pandas.DataFrame representation of the Matrix object
Returns: pandas.DataFrame Return type: pandas.DataFrame
-
class
pyemu.mat.mat_handler.
Jco
(x=None, row_names=[], col_names=[], isdiagonal=False, autoalign=True)[source]¶ Bases:
pyemu.mat.mat_handler.Matrix
a thin wrapper class to get more intuitive attribute names. Functions exactly like Matrix
-
par_names
¶ thin wrapper around Matrix.col_names
Returns: list – parameter names Return type: list
-
obs_names
¶ thin wrapper around Matrix.row_names
Returns: list – observation names Return type: list
-
npar
¶ number of parameters in the Jco
Returns: int – number of parameters (columns) Return type: int
-
nobs
¶ number of observations in the Jco
Returns: int – number of observations (rows) Return type: int
-
replace_cols
(other, parnames=None)[source]¶ Replaces columns in one Matrix with columns from another. Intended for Jacobian matrices replacing parameters.
Parameters: - other (Matrix) – Matrix to use for replacing columns in self
- parnames (list) – parameter (column) names to use in other. If None, all columns in other are used
-
classmethod
from_pst
(pst, random=False)[source]¶ construct a new empty Jco from a control file filled with trash
Parameters: - pst (Pst) – a control file instance. If type is ‘str’, Pst is loaded from filename
- random (bool) – flag for contents of the trash matrix. If True, fill with random numbers, if False, fill with zeros Default is False
Returns: jco – the new Jco instance
Return type:
-
-
class
pyemu.mat.mat_handler.
Cov
(x=None, names=[], row_names=[], col_names=[], isdiagonal=False, autoalign=True)[source]¶ Bases:
pyemu.mat.mat_handler.Matrix
a subclass of Matrix for handling diagonal or dense Covariance matrices todo:block diagonal
-
condition_on
(conditioning_elements)[source]¶ - get a new Covariance object that is conditional on knowing some
- elements. uses Schur’s complement for conditional Covariance propagation
Parameters: conditioning_elements (iterable) – names of elements to condition on Returns: Cov Return type: Cov
-
draw
(mean=1.0)[source]¶ Obtain a random draw from a covariance matrix either with mean==1 or with specified mean vector
Parameters: mean (scalar of enumerable of length self.shape[0]) – mean values. either a scalar applied to to the entire vector of length N or an N-length vector Returns: numpy.nparray – A vector of conditioned values, sampled using the covariance matrix (self) and applied to the mean Return type: numpy.ndarray
-
names
¶ wrapper for getting row_names. row_names == col_names for Cov
Returns: list – names Return type: list
-
replace
(other)[source]¶ replace elements in the covariance matrix with elements from other. if other is not diagonal, then self becomes non diagonal
Parameters: other (Cov) – the Cov to replace elements in self with Note
operates in place
-
to_uncfile
(unc_file, covmat_file='Cov.mat', var_mult=1.0)[source]¶ write a PEST-compatible uncertainty file
Parameters: - unc_file (str) – filename of the uncertainty file
- covmat_file (str Covariance Matrix filename. Default is) –
- If None, and Cov.isdiaonal, then a standard deviation ("Cov.mat".) –
- of the uncertainty file is written. Exception raised if None (form) –
- not Cov.isdiagonal (and) –
- var_mult (float) – variance multiplier for the covmat_file entry
-
classmethod
from_obsweights
(pst_file)[source]¶ instantiates a Cov instance from observation weights in a PEST control file. Calls Cov.from_observation_data()
Parameters: pst_file (str) – pest control file name Returns: Cov Return type: Cov
-
classmethod
from_observation_data
(pst)[source]¶ - instantiates a Cov from a pandas dataframe
- of pyemu.Pst.observation_data
Parameters: pst (pyemu.Pst) – Returns: Cov Return type: Cov
-
classmethod
from_parbounds
(pst_file, sigma_range=4.0, scale_offset=True)[source]¶ Instantiates a Cov from a pest control file parameter data section. Calls Cov.from_parameter_data()
Parameters: - pst_file (str) – pest control file name
- sigma_range (float) – defines range of upper bound - lower bound in terms of standard deviation (sigma). For example, if sigma_range = 4, the bounds represent 4 * sigma. Default is 4.0, representing approximately 95% confidence of implied normal distribution
- scale_offset (bool) – flag to apply scale and offset to parameter upper and lower bounds before calculating varaince. Default is True
Returns: Cov
Return type:
-
classmethod
from_parameter_data
(pst, sigma_range=4.0, scale_offset=True)[source]¶ load Covariances from a pandas dataframe of pyemu.Pst.parameter_data
Parameters: - pst ((pyemu.Pst)) –
- sigma_range (float) – defines range of upper bound - lower bound in terms of standard deviation (sigma). For example, if sigma_range = 4, the bounds represent 4 * sigma. Default is 4.0, representing approximately 95% confidence of implied normal distribution
- scale_offset (bool) – flag to apply scale and offset to parameter upper and lower bounds before calculating varaince. Default is True
Returns: Cov
Return type:
-
classmethod
from_uncfile
(filename)[source]¶ instaniates a Cov from a PEST-compatible uncertainty file
Parameters: filename (str) – uncertainty file name Returns: Cov Return type: Cov
-
static
get_uncfile_dimensions
(filename)[source]¶ quickly read an uncertainty file to find the dimensions
Parameters: filename (str) – uncertainty filename Returns: nentries – number of elements in file Return type: int
-
-
class
pyemu.mat.mat_handler.
SparseMatrix
(x, row_names, col_names)[source]¶ Bases:
object
Note: less rigid about references since this class is for big matrices and don’t want to be making copies
-
shape
¶
-
Module contents¶
This module contains classes for handling matrices in a linear algebra setting. The primary objects are the Matrix() and Cov(). These objects overload most numerical operators to autoalign the elements based on row and column names.


Munthes Gate 29 House / R21 Arkitekter
- Curated by Paula Pintos
- less than a minute
- version="1.0" encoding="UTF-8"? Architects: R21 Arkitekter
- AreaArea of this architecture projectArea: 1400.0 m2
- version="1.0" encoding="UTF-8"?YearCompletion year of this architecture project Year: 2019
- version="1.0" encoding="UTF-8"?PhotographsPhotographs: Åke Eson Lindman
- version="1.0" encoding="UTF-8"?ManufacturersBrands with products used in this architecture project Manufacturers: FAP, Graphisoft, Itlas Pavimenti Legno, Nordic Door, Randers Tegl, Studio Kvänum Oslo, Velfac
- Lead Architects Thomas Thorsnes, Francisco Kocourek, Ola Mo
- Gross Built Area 1400 m2 including garage
More Specs Less Specs
Text description provided by the architects. A listed, regional modernist, low office building at Frogner, Oslo is re-purposed into a residential building with nine apartments in varying sizes, spanning from 77 to 196 m2. The original project was built in 1973, designed by architects Trond Eliassen and Birger Lambertz-Nilssen, they were awarded the “Sundt” prize for architecture due to “Munthes gate”-complex’s outstanding quality.
The building is now listed as a proper representative for the architecture of its period. The transformation strives to preserve this particular character while giving the building a new life. Stepped back from the street, the low profile building extends perpendicularly in the plot creating private green gardens in different levels.
The renovation intends to exploit this existing quality to provide a sequence of inviting rooms both inside and outside. Adapting to the existing bearing structure resulted in nine unique homes, with a different layout and atmosphere, and allowed the opening of new large windows inviting the light and establishing a smooth transition to their private outdoor spaces.
The period's expression is reinforced by staying true to natural materials, oak and copper are used to complement the existing red bricks, while granite stone and corten steel are added to the exterior areas. Formal abstraction, a balanced color scheme and attention to detail contribute to give the building a coherent, warm expression bringing back to life the timeless, classic qualities of the old “Munthes gate 29” award-winning building.


|
fop 1.1 | |||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use org.apache.fop.complexscripts.fonts | |
|---|---|
| org.apache.fop.complexscripts.fonts | |
| org.apache.fop.complexscripts.scripts | |
| org.apache.fop.fonts | Classes for font handling. |
| org.apache.fop.fonts.truetype | Classes for TrueType fonts. |
| Classes in org.apache.fop.complexscripts.fonts used by org.apache.fop.complexscripts.fonts | |
|---|---|
| AdvancedTypographicTableFormatException
Exception thrown when attempting to decode a truetype font file and a format constraint is violated. |
|
| GlyphClassMapping
The GlyphClassMapping interface provides glyph identifier to class
index mapping support. |
|
| GlyphClassTable
Base class implementation of glyph class table. |
|
| GlyphCoverageMapping
The GlyphCoverageMapping interface provides glyph identifier to coverage
index mapping support. |
|
| GlyphCoverageTable
.Base class implementation of glyph coverage table. |
|
| GlyphDefinition
The GlyphDefinition interface is a marker interface implemented by a glyph definition
subtable. |
|
| GlyphDefinitionTable
The GlyphDefinitionTable class is a glyph table that implements
glyph definition functionality according to the OpenType GDEF table. |
|
| GlyphMappingTable
Base class implementation of glyph mapping table. |
|
| GlyphPositioning
The GlyphPositioning interface is implemented by a glyph positioning subtable
that supports the determination of glyph positioning information based on script and
language of the corresponding character content. |
|
| GlyphPositioningState
The GlyphPositioningState implements an state object used during glyph positioning
processing. |
|
| GlyphPositioningSubtable
The GlyphPositioningSubtable implements an abstract base of a glyph subtable,
providing a default implementation of the GlyphPositioning interface. |
|
| GlyphPositioningTable
The GlyphPositioningTable class is a glyph table that implements
GlyphPositioning functionality. |
|
| GlyphPositioningTable.Anchor
The Anchor class implements a anchor record, comprising an X,Y coordinate pair,
an optional anchor point index (or -1), and optional X or Y device tables (or null if absent). |
|
| GlyphPositioningTable.DeviceTable
The DeviceTable class implements a positioning device table record, comprising
adjustments to be made to scaled design units according to the scaled size. |
|
| GlyphPositioningTable.Value
The Value class implements a positioning value record, comprising placement
and advancement information in X and Y axes, and optionally including device data used to
perform device (grid-fitted) specific fine grain adjustments. |
|
| GlyphProcessingState
The GlyphProcessingState implements a common, base state object used during glyph substitution
and positioning processing. |
|
| GlyphSubstitution
The GlyphSubstitution interface is implemented by a glyph substitution subtable
that supports the determination of glyph substitution information based on script and
language of the corresponding character content. |
|
| GlyphSubstitutionState
The GlyphSubstitutionState implements an state object used during glyph substitution
processing. |
|
| GlyphSubstitutionSubtable
The GlyphSubstitutionSubtable implements an abstract base of a glyph substitution subtable,
providing a default implementation of the GlyphSubstitution interface. |
|
| GlyphSubstitutionTable
The GlyphSubstitutionTable class is a glyph table that implements
GlyphSubstitution functionality. |
|
| GlyphSubstitutionTable.Ligature
The Ligature class implements a ligature lookup result in terms of
a ligature glyph (code) and the |
|
| GlyphSubtable
The GlyphSubtable implements an abstract glyph subtable that
encapsulates identification, type, format, and coverage information. |
|
| GlyphTable
Base class for all advanced typographic glyph tables. |
|
| GlyphTable.ClassSequenceRule
The ClassSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph class sequence. |
|
| GlyphTable.CoverageSequenceRule
The CoverageSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph coverage sequence. |
|
| GlyphTable.GlyphSequenceRule
The GlyphSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph sequence. |
|
| GlyphTable.LookupSpec
A structure class encapsulating a lookup specification as a |


Address updated
We've notified the Open Address Register that your address was {% if selectedAddress %}incorrect{% else %}missing{% endif %}. In the future, you won't have to enter it again manually.
We've notified the Open Address Register that your address was {% if selectedAddress %}incorrect{% else %}missing{% endif %}. In the future, you won't have to enter it again manually.