favorite things
things
music
dancing
arts
some favorite stuff
bikes
turtles
people
here are some faves
austin
mark
people related to us
mom
pops


Seems your browser doesn't support Javascript! Websocket relies on Javascript being enabled. Please enable Javascript and reload this page!
Request CACC state:


Methods summary
public
object
&
|
#
getInstance( )
Gets a reference to the Validation object instance
Gets a reference to the Validation object instance
Returns
object Validation instance
|
public
boolean
|
#
alphaNumeric( mixed $check )
Checks that a string contains only integer or letters
Checks that a string contains only integer or letters
Returns true if string contains only integer or letters
$check can be passed as an array: array('check' => 'valueToCheck');
Parameters
- $check
mixed $check Value to check
Returns
boolean Success
|
public
boolean
|
#
between( string $check, integer $min, integer $max )
Checks that a string length is within s specified range. Spaces are included
in the character count. Returns true is string matches value min, max, or
between min and max,
Checks that a string length is within s specified range. Spaces are included
in the character count. Returns true is string matches value min, max, or
between min and max,
Parameters
- $check
string $check Value to check for length
- $min
integer $min Minimum value in range (inclusive)
- $max
integer $max Maximum value in range (inclusive)
Returns
boolean Success
|
public
boolean
|
#
blank( mixed $check )
Returns true if field is left blank -OR- only whitespace characters are
present in it's value Whitespace characters include Space, Tab, Carriage Return,
Newline
Returns true if field is left blank -OR- only whitespace characters are
present in it's value Whitespace characters include Space, Tab, Carriage Return,
Newline
$check can be passed as an array: array('check' => 'valueToCheck');
Parameters
- $check
mixed $check Value to check
Returns
boolean Success
|
public
boolean
|
#
cc( mixed $check, mixed $type = 'fast', boolean $deep = false, string $regex = null )
Validation of credit card numbers. Returns true if $check is in the proper
credit card format.
Validation of credit card numbers. Returns true if $check is in the proper
credit card format.
Parameters
- $check
mixed $check credit card number to validate
- $type
mixed $type 'all' may be passed as a sting, defaults to fast which checks format of
most major credit cards if an array is used only the values of the array are
checked. Example: array('amex', 'bankcard', 'maestro')
- $deep
boolean $deep set to true this will check the Luhn algorithm of the credit card.
- $regex
string $regex A custom regex can also be passed, this will be used instead of the
defined regex values
Returns
boolean Success
See
|
public
boolean
|
#
comparison( mixed $check1, string $operator = null, integer $check2 = null )
Used to compare 2 numeric values.
Used to compare 2 numeric values.
Parameters
- $check1
mixed $check1 if string is passed for a string must also be passed for $check2 used as
an array it must be passed as array('check1' => value, 'operator' =>
'value', 'check2' -> value)
- $operator
string $operator Can be either a word or operand is greater >, is less <, greater
or equal >= less or equal <=, is less <, equal to ==, not equal !=
- $check2
integer $check2 only needed if $check1 is a string
Returns
boolean
|
public
boolean
|
#
custom( mixed $check, string $regex = null )
Used when a custom regular expression is needed.
Used when a custom regular expression is needed.
Parameters
- $check
mixed $check When used as a string, $regex must also be a valid regular expression. As
and array: array('check' => value, 'regex' => 'valid regular expression')
- $regex
string $regex If $check is passed as a string, $regex must also be set to valid regular
expression
Returns
boolean Success
|
public
boolean
|
#
date( string $check, mixed $format = 'ymd', string $regex = null )
Date validation, determines if the string passed is a valid date. keys that
expect full month, day and year will validate leap years
Date validation, determines if the string passed is a valid date. keys that
expect full month, day and year will validate leap years
Parameters
- $check
string $check a valid date string
- $format
mixed $format Use a string or an array of the keys below. Arrays should be passed as
array('dmy', 'mdy', etc) Keys: dmy 27-12-2006 or 27-12-06 separators can be a
space, period, dash, forward slash mdy 12-27-2006 or 12-27-06 separators can be
a space, period, dash, forward slash ymd 2006-12-27 or 06-12-27 separators can
be a space, period, dash, forward slash dMy 27 December 2006 or 27 Dec 2006 Mdy
December 27, 2006 or Dec 27, 2006 comma is optional My December 2006 or Dec 2006
my 12/2006 or 12/06 separators can be a space, period, dash, forward slash
- $regex
string $regex If a custom regular expression is used this is the only validation that
will occur.
Returns
boolean Success
|
public
boolean
|
#
decimal( integer $check, integer $places = null, string $regex = null )
Checks that a value is a valid decimal. If $places is null, the $check is
allowed to be a scientific float If no decimal point is found a false will be
returned. Both the sign and exponent are optional.
Checks that a value is a valid decimal. If $places is null, the $check is
allowed to be a scientific float If no decimal point is found a false will be
returned. Both the sign and exponent are optional.
Parameters
- $check
integer $check The value the test for decimal
- $places
integer $places if set $check value must have exactly $places after the decimal point
- $regex
string $regex If a custom regular expression is used this is the only validation that
will occur.
Returns
boolean Success
|
public
boolean
|
#
email( string $check, boolean $deep = false, string $regex = null )
Validates for an email address.
Validates for an email address.
Parameters
- $check
string $check Value to check
- $deep
boolean $deep Perform a deeper validation (if true), by also checking availability of
host
- $regex
string $regex Regex to use (if none it will use built in regex)
Returns
boolean Success
|
public
|
#
equalTo( mixed $check, mixed $comparedTo )
Check that value is exactly $comparedTo.
Check that value is exactly $comparedTo.
Parameters
- $check
mixed $check Value to check
- $comparedTo
mixed $comparedTo Value to compare
|
public
|
#
extension( mixed $check, array $extensions = array('gif', 'jpeg', 'png', 'jpg') )
Check that value has a valid file extenstion.
Check that value has a valid file extenstion.
Parameters
- $check
mixed $check Value to check
- $extensions
array $extensions file extenstions to allow
|
public
|
#
file( mixed $check )
Check that value is a file type.
Check that value is a file type.
Parameters
- $check
mixed $check Value to check
|
public
boolean
|
#
ip( string $check )
Validation of an IPv4 address.
Validation of an IPv4 address.
Parameters
- $check
string $check The string to test.
Returns
boolean Success
|
public
boolean
|
#
minLength( string $check, integer $min )
Checks whether the length of a string is greater or equal to a minimal
length.
Checks whether the length of a string is greater or equal to a minimal
length.
Parameters
- $check
string $check The string to test
- $min
integer $min The minimal string length
Returns
boolean Success
|
public
boolean
|
#
maxLength( string $check, integer $max )
Checks whether the length of a string is smaller or equal to a maximal
length..
Checks whether the length of a string is smaller or equal to a maximal
length..
Parameters
- $check
string $check The string to test
- $max
integer $max The maximal string length
Returns
boolean Success
|
public
boolean
|
#
money( string $check, string $symbolPosition = 'left' )
Checks that a value is a monetary amount.
Checks that a value is a monetary amount.
Parameters
- $check
string $check Value to check
- $symbolPosition
string $symbolPosition Where symbol is located (left/right)
Returns
boolean Success
|
public
|
#
multiple( mixed $check, mixed $type, string $regex = null )
Validate a multiple select.
Validate a multiple select.
Parameters
- $check
mixed $check Value to check
- $type
mixed $type Type of check
- $regex
string $regex Use custom regular expression
|
public
boolean
|
#
numeric( string $check )
Checks if a value is numeric.
Checks if a value is numeric.
Parameters
- $check
string $check Value to check
Returns
boolean Succcess
|
public
boolean
|
#
phone( mixed $check, string $regex = null, string $country = 'all' )
Check that a value is a valid phone number.
Check that a value is a valid phone number.
Parameters
- $check
mixed $check Value to check (string or array)
- $regex
string $regex Regular expression to use
- $country
string $country Country code (defaults to 'all')
Returns
boolean Success
|
public
boolean
|
#
postal( mixed $check, string $regex = null, string $country = null )
Checks that a given value is a valid postal code.
Checks that a given value is a valid postal code.
Parameters
- $check
mixed $check Value to check
- $regex
string $regex Regular expression to use
- $country
string $country Country to use for formatting
Returns
boolean Success
|
public
|
#
range( string $check, integer $lower = null, integer $upper = null )
Validate that a number is in specified range. if $lower and $upper are not
set, will return true if $check is a legal finite on this platform
Validate that a number is in specified range. if $lower and $upper are not
set, will return true if $check is a legal finite on this platform
Parameters
- $check
string $check Value to check
- $lower
integer $lower Lower limit
- $upper
integer $upper Upper limit
|
public
boolean
|
#
ssn( mixed $check, string $regex = null, string $country = null )
Checks that a value is a valid Social Security Number.
Checks that a value is a valid Social Security Number.
Parameters
- $check
mixed $check Value to check
- $regex
string $regex Regular expression to use
- $country
string $country Country
Returns
boolean Success
|
public
boolean
|
#
url( string $check )
Checks that a value is a valid URL.
Checks that a value is a valid URL.
Parameters
- $check
string $check Value to check
Returns
boolean Success
|
public
mixed
|
#
userDefined( mixed $check, object $object, string $method, array $args = null )
Runs an user-defined validation.
Runs an user-defined validation.
Parameters
- $check
mixed $check value that will be validated in user-defined methods.
- $object
object $object class that holds validation method
- $method
string $method class method name for validation to run
- $args
array $args arguments to send to method
Returns
mixed user-defined class class method returns
|
public
boolean
|
#
_check( )
Runs a regular expression match.
Runs a regular expression match.
Returns
boolean Success of match
|
public
boolean
|
#
_luhn( )
Luhn algorithm
Returns
boolean Success
See
|
public
|
#
__reset( )
Reset internal variables for another validation run.
Reset internal variables for another validation run.
|


A wonderful serenity has taken possession of my entire soul.
I sink under the weight of the splendour of these visions!
I feel the presence of the Almighty, who formed us in his own image.
Get it on your mobile device right now
Sign up to our newsletter for the latest news
© Copyright 2018 Pingendo - All rights reserved.


com.servingxml.components.saxsource
Interfaces
SaxEventBuffer
SaxSourceFactory
XmlSourceFactory
Classes
DomSaxSourceFactory
SaxEventBufferBuilder
SaxEventBufferImpl
SaxEventBufferReader
SaxEventBufferSource
SaxReaderFactory
SaxReaderFactoryAssembler
SaxSourceFactoryAdaptor
SaxSourceXmlSourceFactory
StreamSourceXmlSourceFactory


{% include head.html %} {% include header.html %} {% assign urlsplit = page.url | split:"/" %} {% assign urlsize = urlsplit | size %} {{ urlsplit[4] | upcase }}, {{ urlsplit[3] | upcase }} ({{ urlsplit[2] }}) Note: This is a listing of all tables for the selected MSA/MD region. Choose a table by clicking a row and pressing "Select Table".
Note: This is a listing of all tables for the selected MSA/MD region. Choose a table by clicking a row and pressing "Select Table".


Health Journeys
Live Feed
(updated with each refresh of the page)
Journey Flow
Add your Modules here
Articles by Category
Articles by Tag
Trash
Ignore for Now
Folder
Save for Later
High Tatras
View larger
Delete image
High Tatras 2
View larger
Delete image
High Tatras 3
View larger
Delete image
High Tatras 4
View larger
Delete image
Trash
Trash
* Apply color coding to cats and/or tags


This adapter class populates cards related to categories in the Featured Categories section of the Home page.
More...
Inherits Adapter< CardCategoriesAdapter.CardViewHolder >.
|
| class | CardViewHolder |
| | Holder class to contain all the views required during populating content into it. More...
|
| |
|
| final ArrayList< Integer > | rndList = new ArrayList<>() |
| |
This adapter class populates cards related to categories in the Featured Categories section of the Home page.
| org.buildmlearn.appstore.adapters.CardCategoriesAdapter.CardCategoriesAdapter |
( |
Context |
context, |
|
|
int |
x |
|
) |
| |
Constructor to the Adapter.
- Parameters
-
| context | Context of the activity currently in view/active. |
| x:Number | of categories to be populated |
| int org.buildmlearn.appstore.adapters.CardCategoriesAdapter.getItemCount |
( |
| ) |
|
Gets the total number of cards which is populated.
- Returns
- Size of the Categories-List which is randomly generated
| void org.buildmlearn.appstore.adapters.CardCategoriesAdapter.onBindViewHolder |
( |
final CardViewHolder |
cardViewHolder, |
|
|
int |
i |
|
) |
| |
It binds content to the views.
- Parameters
-
| cardViewHolder:Holder | object which contains all the views which needs to be populated |
| i:Index | of the card, which is being populated. |
| CardViewHolder org.buildmlearn.appstore.adapters.CardCategoriesAdapter.onCreateViewHolder |
( |
ViewGroup |
viewGroup, |
|
|
int |
i |
|
) |
| |
Inflates the layout.
- Parameters
-
| viewGroup:View | group object, which is inflated with the current layout. |
| i | Index of the object |
- Returns
- CardViewHolder object of the current view.
| Context org.buildmlearn.appstore.adapters.CardCategoriesAdapter.mContext |
|
staticprivate |
| final ArrayList<Integer> org.buildmlearn.appstore.adapters.CardCategoriesAdapter.rndList = new ArrayList<>() |
|
private |
The documentation for this class was generated from the following file:
- C:/Users/Srujan/Documents/GitHub/BuildmLearn-Store/Android/source-code/AppStore/app/src/main/java/org/buildmlearn/appstore/adapters/CardCategoriesAdapter.java


Opebi, Ikeja to Awolowo Road, Ikoyi
Trip information
| From: | Opebi, Ikeja |
| To: | Awolowo Road, Ikoyi |
| Departing: | 13th, 2:00pm |
| Vehicle model: | CRV |
| Available seats: | 3 |
| status: | Available |
Driver Profile
Michael
Total Completed Rides offers: 5
| From: | Opebi, Ikeja |
| To: | Awolowo Road, Ikoyi |
| Departing: | 13th, 2:00pm |
| Vehicle model: | CRV |
| Available seats: | 3 |
| status: | Available |
Total Completed Rides offers: 5


Data Analytics Platform
Unfortunately something went wrong:
×
Import File
Data Reset / Deletion
Reset All
Reset to Original Data
Delete selected series
Select dataset
Choose dataset:
Outlier Recognition
Hard limit values
Min
Max
Standard deviation
Std factor
Interpolation
Linear Interpolation
Quadratic Interpolation
Calculate
×
Smoothing
Backward
Forward
Fixed
Window
Calculate
×
I/O Relationship models:
Select input:
Choose one or more datasets:
Select output:
Choose one dataset:
Neural Network
Test Size
Choose Active Function
Identity
Logistic
Tanh
Relu
Choose Solver Function
Lbfgs
Sgd
Adam
Hidden layers
Iterations
Scaling
Random Forest
Trees
Test size
Use history
Calculate
×
Dashboard


This project is focused on building long-lived, survivable software systems that can automatically adapt to new environments. To do so requires the ability to automatically recognize failures in existing devices, detect changes in the operation of existing devices, and adapt to new devices (e.g., sensors) that replace existing devices. We will address this problem by automatically constructing a rich semantic model of input and output data that is manipulated by the system devices. This model will be built using machine learning techniques to recognize and distinguish between various data types and automatic service composition techniques to adapt new devices to support existing functionality and to take advantage of new performance capabilities and features. In this project will develop methods for learning the operations of the existing devices in a system, recognizing the need to adapt due to changes in the operation of a device, and automatically adapting to new devices.


The PWA Toolkit is a starting point for building Progressive Web Apps using Ionic and Stencil. This combination of tools gives you the ability to build a fast, efficient PWA out of the box.
Note: This project is Beta and uses a beta release of @ionic/core
.
For more info check out our homepage!
@ionic/core
for the UI.To start building, clone this repo to a new directory:
npm init stencil ionic-pwa
To build for production, run:
npm run build
A production build includes:
Apps should be hosted on through HTTPS, and if possible, through a provider that supports HTTP2. One provider that does support this is Firebase Hosting.
We recommend setting up HTTP2 Push on Firebase. H2 Push may sound complicated, but it's actually a simple concept. To learn about it, take a look at this article.
To set this up for my-app
:
npm run build
http-server www
.sw.js
file, these are the files you want to H2 push.Service workers are generated via the Stencil build tool. For more information on how they can be configured, see the Service Worker docs.
For most cases, you'll want to develop your app without generating a Service Worker. But if you'd like to test out Web Push Notifications or Background Sync, you'll need to have one generated. To generate a Service Worker during dev builds, we've added the npm script:
npm run start.sw
This will start a dev build and generate a Service Worker as well.
To run the unit tests once, run:
npm test
To run the unit tests and watch for file changes during development, run:
npm run test.watch
We recommend using https://www.webpagetest.org/easy with the Run Lighthouse Audit
option turned on.
This will give you an in depth look into your app's load performance on the average device connected to the average network.
For more info on how to use webpagetest check out this article


Portfolio
BCIT Passion project
BCIT Passion project. Built with mainly bootstrap and a little bit HTML/CSS.
County Project
BCIT 4 Pages County Project featuring Japan. Built with mainly HTML/CSS and a JavaScript add-on in gallery page.
Swagger API Project(Not available now due to AWS service terminated)
My API Project using C# DotNetCore and swagger UI
Book-Review project
Integrated Google Book API to our React JavaScript project for online book comment website
Porton Health Project
Industrial project which fulfill client's needs, contain admin management portal, patient register/check in function, etc.
Youtube channel
Channel used to upload a portion of my assigments for professor's convenience, including IOS Swift, React and C# backend projects.
Get in touch
Please take a few seconds to see what I can offer you.
Learn More About Me


Actors : use case diagram
Created:
27/04/2018 14:04:29
Modified:
27/04/2018 14:27:54
Project:
Author:
alfiva
Version:
1.0
Advanced:
ID:
{1E9A0DE4-3900-4454-91AC-35303BBD38E2}


Re enter room name, chosen room doesnt exist!
Available rooms:
Rooms {{ range . }} {{ .Rooms }} {{ end }}
Room you want to enter:


- valueOf(String) - Static method in enum cmput301.team19.lendz.BookStatus
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum cmput301.team19.lendz.notifications.NotificationType
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum cmput301.team19.lendz.RequestStatus
-
Returns the enum constant of this type with the specified name.
- values() - Static method in enum cmput301.team19.lendz.BookStatus
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum cmput301.team19.lendz.notifications.NotificationType
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum cmput301.team19.lendz.RequestStatus
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- ViewBookFragment - Class in cmput301.team19.lendz
-
Fragment for viewing book details information
Used in BookActivity
- ViewBookFragment() - Constructor for class cmput301.team19.lendz.ViewBookFragment
-
- ViewBooksAdapter - Class in cmput301.team19.lendz
-
- ViewBooksAdapter(Context, ArrayList<ViewBooksSection>, OnBookClickListener) - Constructor for class cmput301.team19.lendz.ViewBooksAdapter
-
- ViewBooksAdapter.ViewHolder - Class in cmput301.team19.lendz
-
- ViewBooksSection - Class in cmput301.team19.lendz
-
Allows section and book data to be passed to
recycler view adapter easily.
- ViewBooksSection(String, ArrayList<Book>) - Constructor for class cmput301.team19.lendz.ViewBooksSection
-
- ViewBooksSectionAdapter - Class in cmput301.team19.lendz
-
- ViewBooksSectionAdapter(Context, ArrayList<Book>, OnBookClickListener) - Constructor for class cmput301.team19.lendz.ViewBooksSectionAdapter
-
- ViewBooksSectionAdapter.ViewHolder - Class in cmput301.team19.lendz
-
- ViewBooksSectionTest - Class in cmput301.team19.lendz
-
Test ViewBooksSection class.
- ViewBooksSectionTest() - Constructor for class cmput301.team19.lendz.ViewBooksSectionTest
-
- ViewHolder(View) - Constructor for class cmput301.team19.lendz.notifications.BookRequestedNotification.ViewHolder
-
- ViewHolder(View) - Constructor for class cmput301.team19.lendz.notifications.RequestAcknowledgedNotification.ViewHolder
-
- ViewHolder(View, OnBookClickListener) - Constructor for class cmput301.team19.lendz.SearchViewAdapter.ViewHolder
-
- ViewHolder(View) - Constructor for class cmput301.team19.lendz.ViewBooksAdapter.ViewHolder
-
- ViewHolder(View, OnBookClickListener) - Constructor for class cmput301.team19.lendz.ViewBooksSectionAdapter.ViewHolder
-
- ViewRequestActivity - Class in cmput301.team19.lendz
-
- ViewRequestActivity() - Constructor for class cmput301.team19.lendz.ViewRequestActivity
-
- ViewRequestCustomAdapter - Class in cmput301.team19.lendz
-
- ViewRequestCustomAdapter(Context, int, List<BorrowerInfo>) - Constructor for class cmput301.team19.lendz.ViewRequestCustomAdapter
-
- ViewUserProfileFragment - Class in cmput301.team19.lendz
-
Fragment for viewing user profile information.
- ViewUserProfileFragment() - Constructor for class cmput301.team19.lendz.ViewUserProfileFragment
-


The $mdSticky
service provides a mixin to make elements sticky.
| Returns |
Description |
|
|
A $mdSticky function that takes three arguments:
scope
element : The element that will be 'sticky'
elementClone : A clone of the element, that will be shown
when the user starts scrolling past the original element.
If not provided, it will use the result of element.clone() .
|


Understanding Docker Underlying Technology
To understand Docker underlying technology, let us first understand the core container technology.
At the core of container technology are cGroups and namespaces. Additionally, Docker uses union file systems(UFS) for added benefits to the container development process. Control groups (cGroups) work by allowing the host to share and also limit the resources each process or container can consume. This is important for both, resource utilization and security, as it prevents denial-of-service attacks on the host’s hardware resources. Several containers can share CPU and memory while staying within the predefined constraints.
Namespaces offer another form of isolation in the way of processes. Processes are limited to see only the process ID in the same namespace. Namespaces from other system processes would not be accessible from a container process. For example, a network namespace would isolate access to the network interfaces and configuration, which allows the separation of network interfaces, routes, and firewall rules.
Union file systems are also a key advantage to using Docker containers. The easiest way to understand union file systems is to think of them like a layer cake with each layer baked independently. The Linux kernel is our base layer; then, we might add an OS like Red Hat Linux or Ubuntu. Next, we might add an application like Nginx or Apache. Every change creates a new layer. Finally, as you make changes and new layers are added, you’ll always have a top layer (think frosting) that is a writable layer.
What makes this truly efficient is that Docker caches the layers the first time we build them. So, let’s say that we have an image with Ubuntu and then add Apache and build the image. Next, we build MySQL with Ubuntu as the base. The second build will be much faster because the Ubuntu layer is already cached. Essentially, our chocolate and vanilla layers, from Figure 1.2, are already baked. We simply need to bake the pistachio (MySQL) layer, assemble, and add the icing (writable layer).
Proceed » Can container communication cross over to noncontainerized apps?


logged in as
@userid
Log out
My Classes
Coursecode
Add Class
Class
Level
Questions
Taken
1
Mark
Otto
@mdo
2
Jacob
Thornton
@fat
3
Larry the Bird
@twitter
View Results


About Sri Venkateswara University
Sri Venkateswara University,Tirupati is established in 1954 on the sprawling campus of 1000 acres with a panaromi and pleasant hill view.The university stands as a testimony to the wisdom and foresight of great Visionaries 'Late Sri Tanguturi Prakasham Pantulu,the then chief minister of Andhra and',Late Sri Neelam Sanjiva Reddy to catter the educational needs and aspirations of the people.
About CSE Department
The department of Computer Science and Engineering was started in the year 1986-87 .This department is offering Undergraduate courses in Computer Science and Engineering and Postgraduate course in Computer Science and Engineering and Postgraduate course in Computer Science and Engineering started in the year 2005
About Cyosure Technical Fest
Cynosure 2020 is a multifaceted technical fest organised to bring out the real talent. This takes you into a whole new world combined with exciting events,unbelievable experience,flaw less creative designs tantalizing quizzes and feet trapping brain teasers.The whole technological ride promises you an awesome experience which is going to be "now or never",and leaves an impression in your minds.
So come join us and have fun filled with great enthusiasm


boids.js
This library simulates bird flock and fish school consists of three simple rules.
seek
arrive
flee
wander
patrol
flock


Nice2Predict is an efficient and scalable open-source framework for structured prediction on programming related problems.
Tools such as the statistical JavaScript deobfuscator JSNice are based on Nice2Predict technology.
Below, is a schema of how the prediction works:


Russia returns three seized Ukrainian ships
by Louis CasianoRussia returned three naval ships captured from Ukraine last year in the Kerch Strait, Russia’s Foreign Ministry said Monday.
The Russian Coast Guard seized two gun boats and a tug boat in November 2018 as the vessels maneuvered near the strait, which runs between Russia and Crimea, annexed from Ukraine.
The Coast Guard fired several shots and detained 24 Ukranian sailors for 10 months following the seizure. They were returned as part of a prisoner exchange.
Ukraine has urged for the return of the ships as a positive gesture ahead of a scheduled Dec. 9 meeting in Paris to discuss a four-way peace agreement on eastern Ukraine.
The plan was brokered by France and Germany and envisions autonomy for separatist regions in eastern Ukraine and amnesty for rebels.
CLICK HERE TO GET THE FOX NEWS APP
Russian President Vladimir Putin informed French President Emmanuel Macron about the ships' return in a phone call Monday.
Ukrainian officials said they will inspect the ships to make sure no equipment is missing.
The Associated Press contributed to this report.


Functions | |
| GLM_FUNC_DECL uint8 | glm::packUnorm1x8 (float v) |
| GLM_FUNC_DECL float | glm::unpackUnorm1x8 (uint8 p) |
| GLM_FUNC_DECL uint16 | glm::packUnorm2x8 (vec2 const &v) |
| GLM_FUNC_DECL vec2 | glm::unpackUnorm2x8 (uint16 p) |
| GLM_FUNC_DECL uint8 | glm::packSnorm1x8 (float s) |
| GLM_FUNC_DECL float | glm::unpackSnorm1x8 (uint8 p) |
| GLM_FUNC_DECL uint16 | glm::packSnorm2x8 (vec2 const &v) |
| GLM_FUNC_DECL vec2 | glm::unpackSnorm2x8 (uint16 p) |
| GLM_FUNC_DECL uint16 | glm::packUnorm1x16 (float v) |
| GLM_FUNC_DECL float | glm::unpackUnorm1x16 (uint16 p) |
| GLM_FUNC_DECL uint64 | glm::packUnorm4x16 (vec4 const &v) |
| GLM_FUNC_DECL vec4 | glm::unpackUnorm4x16 (uint64 p) |
| GLM_FUNC_DECL uint16 | glm::packSnorm1x16 (float v) |
| GLM_FUNC_DECL float | glm::unpackSnorm1x16 (uint16 p) |
| GLM_FUNC_DECL uint64 | glm::packSnorm4x16 (vec4 const &v) |
| GLM_FUNC_DECL vec4 | glm::unpackSnorm4x16 (uint64 const &p) |
| GLM_FUNC_DECL uint16 | glm::packHalf1x16 (float v) |
| GLM_FUNC_DECL float | glm::unpackHalf1x16 (uint16 v) |
| GLM_FUNC_DECL uint64 | glm::packHalf4x16 (vec4 const &v) |
| GLM_FUNC_DECL vec4 | glm::unpackHalf4x16 (uint64 p) |
| GLM_FUNC_DECL uint32 | glm::packI3x10_1x2 (ivec4 const &v) |
| GLM_FUNC_DECL ivec4 | glm::unpackI3x10_1x2 (uint32 p) |
| GLM_FUNC_DECL uint32 | glm::packU3x10_1x2 (uvec4 const &v) |
| GLM_FUNC_DECL uvec4 | glm::unpackU3x10_1x2 (uint32 p) |
| GLM_FUNC_DECL uint32 | glm::packSnorm3x10_1x2 (vec4 const &v) |
| GLM_FUNC_DECL vec4 | glm::unpackSnorm3x10_1x2 (uint32 p) |
| GLM_FUNC_DECL uint32 | glm::packUnorm3x10_1x2 (vec4 const &v) |
| GLM_FUNC_DECL vec4 | glm::unpackUnorm3x10_1x2 (uint32 p) |
| GLM_FUNC_DECL uint32 | glm::packF2x11_1x10 (vec3 const &v) |
| GLM_FUNC_DECL vec3 | glm::unpackF2x11_1x10 (uint32 p) |
<glm/gtc/packing.hpp> need to be included to use these features.
| GLM_FUNC_QUALIFIER uint32 glm::packF2x11_1x10 | ( | vec3 const & | v | ) |
First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values. Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. Then, the results are packed into the returned 32-bit unsigned integer.
The first vector component specifies the 11 least-significant bits of the result; the last component specifies the 10 most-significant bits.
vec3 unpackF2x11_1x10(uint32 const & p)
Definition at line 480 of file packing.inl.
00481 { 00482 return 00483 ((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) | 00484 ((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) | 00485 ((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22); 00486 }
| GLM_FUNC_QUALIFIER uint16 glm::packHalf1x16 | ( | float | v | ) |
Returns an unsigned integer obtained by converting the components of a floating-point scalar to the 16-bit floating-point representation found in the OpenGL Specification, and then packing this 16-bit value into a 16-bit unsigned integer.
uint32 packHalf2x16(vec2 const & v)
uint64 packHalf4x16(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 357 of file packing.inl.
00358 { 00359 int16 Topack = detail::toFloat16(v); 00360 uint16* Packed = reinterpret_cast<uint16*>(&Topack); 00361 return *Packed; 00362 }
| GLM_FUNC_QUALIFIER uint64 glm::packHalf4x16 | ( | glm::vec4 const & | v | ) |
Returns an unsigned integer obtained by converting the components of a four-component floating-point vector to the 16-bit floating-point representation found in the OpenGL Specification, and then packing these four 16-bit values into a 64-bit unsigned integer. The first vector component specifies the 16 least-significant bits of the result; the forth component specifies the 16 most-significant bits.
uint16 packHalf1x16(float const & v)
uint32 packHalf2x16(vec2 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 370 of file packing.inl.
00371 { 00372 i16vec4 Unpack( 00373 detail::toFloat16(v.x), 00374 detail::toFloat16(v.y), 00375 detail::toFloat16(v.z), 00376 detail::toFloat16(v.w)); 00377 00378 uint64* Packed = reinterpret_cast<uint64*>(&Unpack); 00379 return *Packed; 00380 }
| GLM_FUNC_QUALIFIER uint32 glm::packI3x10_1x2 | ( | ivec4 const & | v | ) |
Returns an unsigned integer obtained by converting the components of a four-component signed integer vector to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification, and then packing these four values into a 32-bit unsigned integer. The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.
uint32 packI3x10_1x2(uvec4 const & v)
uint32 packSnorm3x10_1x2(vec4 const & v)
uint32 packUnorm3x10_1x2(vec4 const & v)
ivec4 unpackI3x10_1x2(uint32 const & p)
Definition at line 394 of file packing.inl.
00395 { 00396 detail::i10i10i10i2 Result; 00397 Result.data.x = v.x; 00398 Result.data.y = v.y; 00399 Result.data.z = v.z; 00400 Result.data.w = v.w; 00401 return Result.pack; 00402 }
| GLM_FUNC_QUALIFIER uint16 glm::packSnorm1x16 | ( | float | v | ) |
First, converts the normalized floating-point value v into 16-bit integer value. Then, the results are packed into the returned 16-bit unsigned integer.
The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, -1, +1) * 32767.0)
uint32 packSnorm2x16(vec2 const & v)
uint64 packSnorm4x16(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 327 of file packing.inl.
References glm::clamp(), and glm::round().
00328 { 00329 int16 Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); 00330 uint16* Packed = reinterpret_cast<uint16*>(&Topack); 00331 return *Packed; 00332 }
| GLM_FUNC_QUALIFIER uint8 glm::packSnorm1x8 | ( | float | s | ) |
First, converts the normalized floating-point value v into 8-bit integer value. Then, the results are packed into the returned 8-bit unsigned integer.
The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, -1, +1) * 127.0)
uint16 packSnorm2x8(vec2 const & v)
uint32 packSnorm4x8(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 273 of file packing.inl.
References glm::clamp(), and glm::round().
00274 { 00275 int8 Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f))); 00276 uint8* Packed = reinterpret_cast<uint8*>(&Topack); 00277 return *Packed; 00278 }
| GLM_FUNC_QUALIFIER uint16 glm::packSnorm2x8 | ( | vec2 const & | v | ) |
First, converts each component of the normalized floating-point value v into 8-bit integer values. Then, the results are packed into the returned 16-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm2x8: round(clamp(c, -1, +1) * 127.0)
The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.
uint8 packSnorm1x8(float const & v)
uint32 packSnorm4x8(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 288 of file packing.inl.
References glm::clamp(), and glm::round().
00289 { 00290 i8vec2 Topack(round(clamp(v ,-1.0f, 1.0f) * 127.0f)); 00291 uint16* Packed = reinterpret_cast<uint16*>(&Topack); 00292 return *Packed; 00293 }
| GLM_FUNC_QUALIFIER uint32 glm::packSnorm3x10_1x2 | ( | vec4 const & | v | ) |
First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values. Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values. Then, the results are packed into the returned 32-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm3x10_1x2(xyz): round(clamp(c, -1, +1) * 511.0) packSnorm3x10_1x2(w): round(clamp(c, -1, +1) * 1.0)
The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.
vec4 unpackSnorm3x10_1x2(uint32 const & p)
uint32 packUnorm3x10_1x2(vec4 const & v)
Definition at line 436 of file packing.inl.
References glm::clamp(), and glm::round().
00437 { 00438 detail::i10i10i10i2 Result; 00439 Result.data.x = int(round(clamp(v.x,-1.0f, 1.0f) * 511.f)); 00440 Result.data.y = int(round(clamp(v.y,-1.0f, 1.0f) * 511.f)); 00441 Result.data.z = int(round(clamp(v.z,-1.0f, 1.0f) * 511.f)); 00442 Result.data.w = int(round(clamp(v.w,-1.0f, 1.0f) * 1.f)); 00443 return Result.pack; 00444 }
| GLM_FUNC_QUALIFIER uint64 glm::packSnorm4x16 | ( | vec4 const & | v | ) |
First, converts each component of the normalized floating-point value v into 16-bit integer values. Then, the results are packed into the returned 64-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm2x8: round(clamp(c, -1, +1) * 32767.0)
The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.
uint16 packSnorm1x16(float const & v)
uint32 packSnorm2x16(vec2 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 342 of file packing.inl.
References glm::clamp(), and glm::round().
00343 { 00344 i16vec4 Topack = static_cast<i16vec4>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); 00345 uint64* Packed = reinterpret_cast<uint64*>(&Topack); 00346 return *Packed; 00347 }
| GLM_FUNC_QUALIFIER uint32 glm::packU3x10_1x2 | ( | uvec4 const & | v | ) |
Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification, and then packing these four values into a 32-bit unsigned integer. The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.
uint32 packI3x10_1x2(ivec4 const & v)
uint32 packSnorm3x10_1x2(vec4 const & v)
uint32 packUnorm3x10_1x2(vec4 const & v)
ivec4 unpackU3x10_1x2(uint32 const & p)
Definition at line 415 of file packing.inl.
00416 { 00417 detail::u10u10u10u2 Result; 00418 Result.data.x = v.x; 00419 Result.data.y = v.y; 00420 Result.data.z = v.z; 00421 Result.data.w = v.w; 00422 return Result.pack; 00423 }
| GLM_FUNC_QUALIFIER uint16 glm::packUnorm1x16 | ( | float | v | ) |
First, converts the normalized floating-point value v into a 16-bit integer value. Then, the results are packed into the returned 16-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm1x16: round(clamp(c, 0, +1) * 65535.0)
uint16 packSnorm1x16(float const & v)
uint64 packSnorm4x16(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 303 of file packing.inl.
References glm::clamp(), and glm::round().
| GLM_FUNC_QUALIFIER uint8 glm::packUnorm1x8 | ( | float | v | ) |
First, converts the normalized floating-point value v into a 8-bit integer value. Then, the results are packed into the returned 8-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm1x8: round(clamp(c, 0, +1) * 255.0)
uint16 packUnorm2x8(vec2 const & v)
uint32 packUnorm4x8(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 249 of file packing.inl.
References glm::clamp(), and glm::round().
| GLM_FUNC_QUALIFIER uint16 glm::packUnorm2x8 | ( | vec2 const & | v | ) |
First, converts each component of the normalized floating-point value v into 8-bit integer values. Then, the results are packed into the returned 16-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm2x8: round(clamp(c, 0, +1) * 255.0)
The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.
uint8 packUnorm1x8(float const & v)
uint32 packUnorm4x8(vec4 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 260 of file packing.inl.
References glm::clamp(), and glm::round().
00261 { 00262 u8vec2 Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f)); 00263 uint16* Packed = reinterpret_cast<uint16*>(&Topack); 00264 return *Packed; 00265 }
| GLM_FUNC_QUALIFIER uint32 glm::packUnorm3x10_1x2 | ( | vec4 const & | v | ) |
First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values. Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values. Then, the results are packed into the returned 32-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm3x10_1x2(xyz): round(clamp(c, 0, +1) * 1023.0) packUnorm3x10_1x2(w): round(clamp(c, 0, +1) * 3.0)
The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.
vec4 unpackUnorm3x10_1x2(uint32 const & p)
uint32 packUnorm3x10_1x2(vec4 const & v)
Definition at line 458 of file packing.inl.
References glm::clamp(), and glm::round().
00459 { 00460 detail::i10i10i10i2 Result; 00461 Result.data.x = int(round(clamp(v.x, 0.0f, 1.0f) * 1023.f)); 00462 Result.data.y = int(round(clamp(v.y, 0.0f, 1.0f) * 1023.f)); 00463 Result.data.z = int(round(clamp(v.z, 0.0f, 1.0f) * 1023.f)); 00464 Result.data.w = int(round(clamp(v.w, 0.0f, 1.0f) * 3.f)); 00465 return Result.pack; 00466 }
| GLM_FUNC_QUALIFIER uint64 glm::packUnorm4x16 | ( | vec4 const & | v | ) |
First, converts each component of the normalized floating-point value v into 16-bit integer values. Then, the results are packed into the returned 64-bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm4x16: round(clamp(c, 0, +1) * 65535.0)
The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.
uint16 packUnorm1x16(float const & v)
uint32 packUnorm2x16(vec2 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 314 of file packing.inl.
References glm::clamp(), and glm::round().
00315 { 00316 u16vec4 Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f)); 00317 uint64* Packed = reinterpret_cast<uint64*>(&Topack); 00318 return *Packed; 00319 }
| GLM_FUNC_QUALIFIER vec3 glm::unpackF2x11_1x10 | ( | uint32 | p | ) |
First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value . Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
Definition at line 488 of file packing.inl.
00489 { 00490 return vec3( 00491 detail::packed11bitToFloat(v >> 0), 00492 detail::packed11bitToFloat(v >> 11), 00493 detail::packed10bitToFloat(v >> 22)); 00494 }
| GLM_FUNC_QUALIFIER float glm::unpackHalf1x16 | ( | uint16 | v | ) |
Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value, interpreted as a 16-bit floating-point number according to the OpenGL Specification, and converting it to 32-bit floating-point values.
vec2 unpackHalf2x16(uint32 const & v)
vec4 unpackHalf4x16(uint64 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 364 of file packing.inl.
00365 { 00366 int16* Unpack = reinterpret_cast<int16*>(const_cast<uint16*>(&v)); 00367 return detail::toFloat32(*Unpack); 00368 }
| GLM_FUNC_QUALIFIER glm::vec4 glm::unpackHalf4x16 | ( | uint64 | p | ) |
Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values, interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, and converting them to 32-bit floating-point values. The first component of the vector is obtained from the 16 least-significant bits of v; the forth component is obtained from the 16 most-significant bits of v.
float unpackHalf1x16(uint16 const & v)
vec2 unpackHalf2x16(uint32 const & v)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 382 of file packing.inl.
00383 { 00384 i16vec4* p = reinterpret_cast<i16vec4*>(const_cast<uint64*>(&v)); 00385 i16vec4 Unpack(*p); 00386 00387 return vec4( 00388 detail::toFloat32(Unpack.x), 00389 detail::toFloat32(Unpack.y), 00390 detail::toFloat32(Unpack.z), 00391 detail::toFloat32(Unpack.w)); 00392 }
| GLM_FUNC_QUALIFIER ivec4 glm::unpackI3x10_1x2 | ( | uint32 | p | ) |
Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers.
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
uint32 packU3x10_1x2(uvec4 const & v)
vec4 unpackSnorm3x10_1x2(uint32 const & p);
uvec4 unpackI3x10_1x2(uint32 const & p);
Definition at line 404 of file packing.inl.
00405 { 00406 detail::i10i10i10i2 Unpack; 00407 Unpack.pack = v; 00408 return ivec4( 00409 Unpack.data.x, 00410 Unpack.data.y, 00411 Unpack.data.z, 00412 Unpack.data.w); 00413 }
| GLM_FUNC_QUALIFIER float glm::unpackSnorm1x16 | ( | uint16 | p | ) |
First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers. Then, each component is converted to a normalized floating-point value to generate the returned scalar.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm1x16: clamp(f / 32767.0, -1, +1)
vec2 unpackSnorm2x16(uint32 p)
vec4 unpackSnorm4x16(uint64 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 334 of file packing.inl.
References glm::clamp(), and glm::e().
00335 { 00336 float Unpack = static_cast<float>(*const_cast<uint16*>(&p)); 00337 return clamp( 00338 Unpack * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, 00339 -1.0f, 1.0f); 00340 }
| GLM_FUNC_QUALIFIER float glm::unpackSnorm1x8 | ( | uint8 | p | ) |
First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers. Then, the value is converted to a normalized floating-point value to generate the returned scalar.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm1x8: clamp(f / 127.0, -1, +1)
vec4 unpackSnorm4x8(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 280 of file packing.inl.
References glm::clamp().
00281 { 00282 float Unpack(static_cast<float>(*const_cast<uint8*>(&p))); 00283 return clamp( 00284 Unpack * 0.00787401574803149606299212598425f, // 1.0f / 127.0f 00285 -1.0f, 1.0f); 00286 }
| GLM_FUNC_QUALIFIER vec2 glm::unpackSnorm2x8 | ( | uint16 | p | ) |
First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers. Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm2x8: clamp(f / 127.0, -1, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
float unpackSnorm1x8(uint8 p)
vec4 unpackSnorm4x8(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 295 of file packing.inl.
References glm::clamp().
00296 { 00297 i8vec2* Unpack = reinterpret_cast<i8vec2*>(const_cast<uint16*>(&p)); 00298 return clamp( 00299 vec2(*Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f 00300 -1.0f, 1.0f); 00301 }
| GLM_FUNC_QUALIFIER vec4 glm::unpackSnorm3x10_1x2 | ( | uint32 | p | ) |
First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, -1, +1) unpackSnorm3x10_1x2(w): clamp(f / 511.0, -1, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
uint32 packSnorm3x10_1x2(vec4 const & v)
vec4 unpackUnorm3x10_1x2(uint32 const & p))
uvec4 unpackI3x10_1x2(uint32 const & p)
uvec4 unpackU3x10_1x2(uint32 const & p)
Definition at line 446 of file packing.inl.
References glm::clamp().
00447 { 00448 detail::i10i10i10i2 Unpack; 00449 Unpack.pack = v; 00450 vec4 Result; 00451 Result.x = clamp(float(Unpack.data.x) / 511.f, -1.0f, 1.0f); 00452 Result.y = clamp(float(Unpack.data.y) / 511.f, -1.0f, 1.0f); 00453 Result.z = clamp(float(Unpack.data.z) / 511.f, -1.0f, 1.0f); 00454 Result.w = clamp(float(Unpack.data.w) / 1.f, -1.0f, 1.0f); 00455 return Result; 00456 }
| GLM_FUNC_DECL vec4 glm::unpackSnorm4x16 | ( | uint64 const & | p | ) |
First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers. Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm4x16: clamp(f / 32767.0, -1, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
float unpackSnorm1x16(uint16 p)
vec2 unpackSnorm2x16(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
| GLM_FUNC_QUALIFIER uvec4 glm::unpackU3x10_1x2 | ( | uint32 | p | ) |
Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers.
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
uint32 packU3x10_1x2(uvec4 const & v)
vec4 unpackSnorm3x10_1x2(uint32 const & p);
uvec4 unpackI3x10_1x2(uint32 const & p);
Definition at line 425 of file packing.inl.
00426 { 00427 detail::u10u10u10u2 Unpack; 00428 Unpack.pack = v; 00429 return uvec4( 00430 Unpack.data.x, 00431 Unpack.data.y, 00432 Unpack.data.z, 00433 Unpack.data.w); 00434 }
| GLM_FUNC_QUALIFIER float glm::unpackUnorm1x16 | ( | uint16 | p | ) |
First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers. Then, the value is converted to a normalized floating-point value to generate the returned scalar.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm1x16: f / 65535.0
vec2 unpackUnorm2x16(uint32 p)
vec4 unpackUnorm4x16(uint64 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 308 of file packing.inl.
00309 { 00310 float Unpack = static_cast<float>(*const_cast<uint16*>(&p)); 00311 return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 00312 }
| GLM_FUNC_QUALIFIER float glm::unpackUnorm1x8 | ( | uint8 | p | ) |
Convert a single 8-bit integer to a normalized floating-point value.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm4x8: f / 255.0
vec4 unpackUnorm4x8(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 254 of file packing.inl.
00255 { 00256 float Unpack(static_cast<float>(p)); 00257 return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255 00258 }
| GLM_FUNC_QUALIFIER vec2 glm::unpackUnorm2x8 | ( | uint16 | p | ) |
First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers. Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm4x8: f / 255.0
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
float unpackUnorm1x8(uint8 v)
vec4 unpackUnorm4x8(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 267 of file packing.inl.
00268 { 00269 u8vec2* Unpacked = reinterpret_cast<u8vec2*>(const_cast<uint16*>(&p)); 00270 return vec2(*Unpacked) * float(0.0039215686274509803921568627451); // 1 / 255 00271 }
| GLM_FUNC_QUALIFIER vec4 glm::unpackUnorm3x10_1x2 | ( | uint32 | p | ) |
First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1) unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
uint32 packSnorm3x10_1x2(vec4 const & v)
vec4 unpackInorm3x10_1x2(uint32 const & p))
uvec4 unpackI3x10_1x2(uint32 const & p)
uvec4 unpackU3x10_1x2(uint32 const & p)
Definition at line 468 of file packing.inl.
00469 { 00470 detail::i10i10i10i2 Unpack; 00471 Unpack.pack = v; 00472 vec4 Result; 00473 Result.x = float(Unpack.data.x) / 1023.f; 00474 Result.y = float(Unpack.data.y) / 1023.f; 00475 Result.z = float(Unpack.data.z) / 1023.f; 00476 Result.w = float(Unpack.data.w) / 3.f; 00477 return Result; 00478 }
| GLM_FUNC_QUALIFIER vec4 glm::unpackUnorm4x16 | ( | uint64 | p | ) |
First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers. Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnormx4x16: f / 65535.0
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
float unpackUnorm1x16(uint16 p)
vec2 unpackUnorm2x16(uint32 p)
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Definition at line 321 of file packing.inl.
00322 { 00323 u16vec4* Unpack = reinterpret_cast<u16vec4*>(const_cast<uint64*>(&p)); 00324 return vec4(*Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 00325 }


7.11.15
I believe the DBC expierence is going to be a very new to me which is exciting and scary at the same time. At first I was a little nervous about what was required to become a DBC student. But after watching the way they teach and communicate as a whole, has really eased my nerves. The way they have created a system for all levels of experience to work together is very reassuring. My impression is that its going to be a very fast pace, but friendly learning environment. DBC encourages to learn from mistakes while other programs, I feel do the complete opposite. Im very excited to jump into this environment because I feel it will full benefit me although I am a bit nervous. I think after I get my first full day on site I will be ready to roll.


from __future__ import unicode_literals
import json
import os
import urllib
from nltk import pos_tag
from nltk import tree as ntree
from nltk.stem import WordNetLemmatizer
import wordnet_utils as wu
from pepper import logger
LOG = logger.getChild(__name__)
wnl = WordNetLemmatizer()
ROOT = os.path.join(os.path.dirname(__file__), '..')
lexicon = json.load(open(os.path.join(ROOT, 'data', 'lexicon.json')))
[docs]def trim_dash(triple):
"""
:param triple: a set with three elements (subject, object, complement)
:return: clean triple with extra dashes removed
"""
for el in triple:
if triple[el]:
if triple[el].startswith('-'):
triple[el] = triple[el][1:]
if triple[el].endswith('-'):
triple[el] = triple[el][:-1]
return triple
[docs]def get_triple_element_type(element, forest):
"""
:param element: text of one element from the triple
:param forest: parsed tree
:return: dictionary with semantic types of the element or sub-elements
"""
types = {}
if '-' in element:
text = ''
for el in element.split('-'):
text += el + ' '
text = text.strip()
uris = get_uris(text)
# print('LOOKUP: ', text, len(uris))
# if len(uris) > 0:
# print('URI ', text, len(uris))
# entities with more than 1 uri from DBpedia are NE and collocations
if len(uris) > 1:
return 'NE-col'
# collocations which exist in WordNet
synsets = wu.get_synsets(text, get_pos_in_tree(forest, text))
if len(synsets):
typ = wu.get_lexname_in_tree(synsets)
return typ + '-col'
# if entity does not exist in DBP or WN it is considered composite
for el in element.split('-'):
types[el] = get_word_type(el, forest)
else:
types[element] = get_word_type(element, forest)
return types
[docs]def get_word_type(word, forest):
"""
:param word: one word from triple element
:param forest: parsed syntax tree
:return: semantic type of word
"""
if word == '':
return ''
lexname = get_lexname_in_tree(word, forest)
if lexname is not None:
return lexname
# words which don't have a lexname are looked up in the lexicon
entry = lexicon_lookup(word)
if entry is not None:
if 'proximity' in entry:
return 'deictic:' + entry['proximity'] + ',' + entry['number']
if 'person' in entry:
return 'pronoun:' + entry['person']
if 'root' in entry:
return 'modal:' + str(entry['root'])
if 'definite' in entry:
return 'article:' + entry
if 'integer' in entry:
return 'numeral:' + entry['integer']
types = {'NN': 'person', 'V': 'verb', 'IN': 'prep', 'TO': 'prep', 'MD': 'modal'}
# for words which are not in the lexicon nor have a lexname, the sem.type is derived from the POS tag
pos = pos_tag([word])[0][1]
if pos in types:
return types[pos]
node = get_pos_in_tree(forest, word)
if node in types:
return types[node]
[docs]def get_lexname_in_tree(word, forest):
'''
:param word: word for which we want a WordNe lexname
:param forest: parsed forest of the sentence, to extract the POS tag
:return: lexname of the word
https://wordnet.princeton.edu/documentation/lexnames5wn
'''
if word == '':
return
label = get_pos_in_tree(forest[0], word)
if label == '':
label = pos_tag([word])
if label == '':
return None
label = label[0][1]
synset = wu.get_synsets(word, label)
if synset:
type = wu.get_lexname_in_tree(synset[0])
return type
else:
return None
[docs]def fix_pronouns(pronoun, self):
"""
:param pronoun: personal ronoun which is said in the sentence
:param self: Utterance object from which we can get the speaker and lexicon
:return: disambiguated first or second person pronoun
In the case of third person pronouns - guesses or asks questions
* plural *
"""
speaker = self.chat.speaker
entry = lexicon_lookup(pronoun, lexicon)
if entry and 'person' in entry:
if entry['person'] == 'first':
return speaker
elif entry['person'] == 'second':
return 'leolani'
else:
# print('disambiguate third person')
return pronoun
else:
return pronoun
[docs]def lemmatize(word, tag=''):
"""
This function uses the WordNet lemmatizer
:param word: word to be lemmatized
:param tag: POS tag of word
:return: word lemma
"""
lem = ''
if len(word.split()) > 1:
for el in word.split():
lem += wnl.lemmatize(el) + ' '
return lem.strip()
if tag != '':
return wnl.lemmatize(word, tag)
return wnl.lemmatize(word)
[docs]def get_pos_in_tree(tree, word):
"""
This function extracts POS tag of a word from the parsed syntax tree
:param tree: syntax tree gotten from initial CFG parsing
:param word: word whose POS tag we want
:return: POS tag of the word
"""
label = ''
for el in tree:
for node in el:
if type(node) == ntree.Tree:
for subtree in node.subtrees():
for n in subtree:
if n == word:
label = str(subtree.label())
return label
[docs]def lexicon_lookup(word, typ=None):
"""
Look up and return features of a given word in the lexicon.
:param word: word which we're looking up
:param typ: type of word, if type is category then returns the lexicon entry and the word type
:return: lexicon entry of the word
"""
# Define pronoun categories.
pronouns = lexicon["pronouns"]
subject_pros = pronouns["subject"]
object_pros = pronouns["object"]
possessive_pros = pronouns["possessive"]
dep_possessives = possessive_pros["dependent"]
indep_possessives = possessive_pros["independent"]
reflexive_pros = pronouns["reflexive"]
indefinite_pros = pronouns["indefinite"]
indefinite_person = indefinite_pros["person"]
indefinite_place = indefinite_pros["place"]
indefinite_thing = indefinite_pros["thing"]
# Define verbal categories.
verbs = lexicon["verbs"]
to_be = verbs["to be"]
aux_verbs = verbs["auxiliaries"]
have = aux_verbs['have']
to_do = aux_verbs["to do"]
modals = aux_verbs["modals"]
lexicals = verbs["lexical verbs"]
# Define determiner categories.
determiners = lexicon["determiners"]
articles = determiners["articles"]
demonstratives = determiners["demonstratives"]
possessive_dets = determiners["possessives"]
quantifiers = determiners["quantifiers"]
wh_dets = determiners["wh-determiners"]
numerals = determiners["numerals"]
cardinals = numerals["cardinals"]
ordinals = numerals["ordinals"]
s_genitive = determiners["s-genitive"]
# Define conjunction categories.
conjunctions = lexicon["conjunctions"]
coordinators = conjunctions["coordinating"]
subordinators = conjunctions["subordinating"]
# Define a question word category.
question_words = lexicon["question words"]
# Define a kinship category.
kinship = lexicon["kinship"]
if typ == 'verb':
categories = [to_be,
to_do,
have,
modals,
lexicals]
elif typ == 'pos':
categories = [dep_possessives]
elif typ == 'to_be':
categories = [to_be]
elif typ == 'aux':
categories = [to_do, to_be, have]
elif typ == 'modal':
categories = [modals]
elif typ == 'pronouns':
categories = [subject_pros,
object_pros,
dep_possessives,
indep_possessives,
reflexive_pros,
indefinite_person,
indefinite_place,
indefinite_thing]
elif typ == 'lexical':
categories = [lexicals]
elif typ == 'kinship':
categories = [kinship]
elif typ == 'det':
categories = [articles, demonstratives, possessive_dets, possessive_pros, cardinals, ordinals]
else:
categories = [subject_pros,
object_pros,
dep_possessives,
indep_possessives,
reflexive_pros,
indefinite_person,
indefinite_place,
indefinite_thing,
to_be,
to_do,
have,
modals,
lexicals,
articles,
demonstratives,
possessive_dets,
quantifiers,
wh_dets,
cardinals,
ordinals,
s_genitive,
coordinators,
subordinators,
question_words,
kinship]
for category in categories:
for item in category:
if word == item:
if typ == 'category':
return category, category[item]
return category[item]
return None
[docs]def dbp_query(q, base_url, format="application/json"):
"""
:param q: query for DBpedia
:param base_url: URL to connect to DBpedia
:param format: format for query, typically json
:return: json with DBpedia responses
"""
params = {
"default-graph": "",
"should-sponge": "soft",
"query": q,
"debug": "on",
"timeout": "",
"format": format,
"save": "display",
"fname": ""
}
querypart = urllib.urlencode(params)
response = urllib.urlopen(base_url, querypart).read()
return json.loads(response)
[docs]def get_uris(string):
"""
:param string: string which we are querying for
:return: set of URIS from DBpedia for the queried string
"""
query = """PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?pred WHERE {
?pred rdfs:label """ + "'" + string + "'" + """@en .
}
ORDER BY ?pred"""
try:
results = dbp_query(query, "http://dbpedia.org/sparql")
uris = []
for x in results['results']['bindings']:
uris.append(x['pred']['value'])
except:
uris = []
return uris


SCARFACE A film review by David Landers Copyright 1997 David Landers
RATING: *** 1/2 out of **** - 8.0 out of 10.0 CAST: Al Pacino (Tony Montana), Steven Bauer (Manolo Manny Ray), Michelle Pfeiffer (Elvira), Mary Elizabeth Mastrantonio (Gina), Robert Loggia (Frank Lopez) DIRECTOR: Brian DePalma CERTIFICATION: R (USA) for excessive language and violence YEAR OF PRODUCTION: 1983
SCARFACE, a remake of the 1932 film of the same name, is a very gripping and, as far as I know, a true-to-life story of how power and violence lead to corruption. Al Pacino, as Tony Montana (for whom the movie is named), also provides a brilliant performance as a Cuban refugee who comes to America with less than nothing and becomes one of the most highly respected and feared drug lords in Miami. Oliver Stone also penned the screenplay in one of his earlier writing roles.
The film begins by disclosing the story of now Fidel Castro ordered thousands of Cubans to set sail and head for the coasts of the United States. Many of these Cubans had criminal records, such as Tony Montana, a cocky, fast-talking man who has the look of crime. Nearly right after his arrival in Miami, Tony is thrust into the gangster life when he participates in a cocaine buy that goes awry.
Along with his friend and partner, Manolo (Steven Bauer), Tony rises in the gangster ranks when he forms a friendship with Frank Lopez (Robert Loggia), a high-roller in the organized crime field. Tony also begins to fall in love with Elvira (Michelle Pfeiffer), who at the time was Frank's lover. Of course, sooner or later in this industry, betrayal and corruption amount into a force greater than anything else, and Tony is one of the ones who fall victim to this force. This is not before he becomes one of the most respected, and often feared, men in Miami. Tony gets to the point where he cannot trust anyone, and everyone he knows basically feels the same way towards him. No one can trust him, and basically, no one does.
SCARFACE, although incredibly violent, is one of the best crime films of its time and stands out as another great performance for Al Pacino. Although he did not receive any recognition from the Academy for his performance, it truly is a very good one. In fact, his accent and facial movements alone are enough in my mind to win at least a nomination (although he did get a Golden Globe nomination).
Another element that stands out when someone mentions this film is the profanity. A figure tagged to the film boasts that the word "fuck" and it's uses are uttered 206 times throughout the film, which is apparently a record. The thing is, the vulgarity fits rather well with the movie. As odd as it sounds, it's true. In the end, SCARFACE is a very powerful film that hits home hard.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


container 1
Draggable #1
Sub Dragable #1.1
Sub Dragable #1.2
container 2
Draggable #2
Sub Dragable #2.1
Sub Dragable #2.2


Front-end component library
Bootstrap is an open source toolkit for developing with HTML, CSS, and JS. Quickly prototype your ideas or build your entire app with our Sass variables and mixins, responsive grid system, extensive prebuilt components, and powerful plugins built on jQuery.
Bootstrap’s grid system uses a series of containers, rows, and columns to layout and align content. It’s built with flexbox and is fully responsive. Below is an example and an in-depth look at how the grid comes together.
Using the themes is as easy as downloading a CSS file and replacing the one that comes with Bootstrap. You can install as a package via npm with the command npm install bootswatch. You can also hotlink the themes via CDN at BootstrapCDN.


Toilet papers. A trivial household item, but touches us in our everyday lives. Amazon.com lists over 50 brands of Toilet Papers. With over 9000 product listings, how exactly does one pick the right toilet paper - hopefully in a quantified, scientific way?
Let us look at the possible methods of evaluation:
These often involve analyzing the physical characteristics of TP using tests such as the following:
The good part about such types of evaluations is that they can be completely objective. The tests (if conducted properly) can provide objective and precise measurements.
The issue with this kind of evaluation, though, is that it is often impossible to arrive at tests that can grade each and every aspect of a product or incorporate actual consumer experiences - for example. what kind of a test can be used to quantify “comfort” ?
A possible solution to the above problem, is to perhaps involve the consumers in the grading process - after all who better to measure the product than the end users of the product itself!
Surveys work great if designed right. However, designing the right survey to incite unbiased responses can be challenging due to factors like Response Bias. Even if we were to be able to come up with a questionnaire that records participants true responses across all aspects of the product, keeping it updated over time can get challenging.
Reviews are informative nuggets of free text and are already available for most products that are sold on the internet. They are the voice of the consumers in a public forum.
” People often talk about the things they care about “
… and the same is true for online reviews.
By itself, a single review represents an individual’s experience - but these become even more interesting when we start to look at repeated patterns across many reviews.
What if we could use this information to scientifically come up with conclusions about the product?
Using Neural Networks + Natural Language Processing, it is possible to extract the topics and sentiment, enabling us to quantify objective metrics for the product.
Now let’s try and analyze TP reviews from Amazon.com.
After crawling Amazon.com to gather reviews, we need to preprocess the data to address the following issues:
After the above clean ups, we end up with 29574 reviews across 274 products (only considering upto 1000 most recent reviews for each product).
We can now cluster the review sentences to extract the most spoken about topics in the reviews. Following are the recurring topics that start to emerge:
| TOPIC CLUSTERS | SAMPLE PHRASES |
| Overall | "the product was great", "did the job" ... |
| Marketplace / Delivery | "was delivered on time", "doorstep delivery" ... |
| Paper Quality | "strong", "durable", "doesn't tear" ... |
| Comfort | "soft", "cushy", "softest TP out there", "little ruff on the bum" ... |
| Value For Money | "worth the price", "bargain", "rip off" ... |
| Lasts Long | "lasts forever", "ran out in a day", "larger than expected" ... |
| Cleaning | "squeaky clean bum", "leaves quite a bit of fuzz behind" ... |
| Clogging | "clogs the sewer line", "gentle on the plumbing", "had to use the plunger" ... |
| Dispenser | "barely fit my holder", "might not fit in your dispenser" ... |
| Gag Gift | "gag gift for my roommate", "gift as a prank" ... |
| Eco-Friendly | "environmentally friendly", "made of recycled paper" ... |
| Travel | "carry in your purse or pocket", "great for travel" ... |
| Perfumed TPs | "smell is so strong", "smell soooooo good" ... |
For the purpose of this exercise, we will not consider the top two topics in the above list - reason being that the “Overall Product” statements are too generic, loosely used and volume-wise dominates every other topic, and the “Marketplace / Delivery” topic is not directly related to the product. We discard the (bottom four) low volume clusters as well.
Let’s look at the final set of clusters with their volume distribution:
All the cluster sentences are then passed through our custom sentiment classifier to arrive at the positive and negative polarity. This gives us a topic-wise polarity of the products. We can now start to compare topics across products to arrive at an overall product ranking.
The best products, according to our analysis are (#1, #2):
… and the worst products on our list are (#243, #242):
Note that we not only have a ranking, but also a justification - for example the worst product is a Tubeless TP, which seems to have a lot of holder / dispenser related compaints.
We can even sort by any topic and pick the topic-wise best products, for example the best TPs for preventing clogging are (Clog #1, Clog #2):
Why stop at just toilet papers?
We at TheReviewIndex.com believe that similar techniques can be used for analyzing all kinds of reviews - which is why we’ve just launched a tool that creates spam filtered review summaries for any Amazon.com electronic / gadget / appliance.
You can try it out here:


Hafizh Syahrin targets top five position in Moto2 next season
PETALING JAYA, Nov 7 — National motorcycle maestro, Hafizh Syahrin Abdullah has shown he does not give up easily for his love of motoring sports despite facing a downgrade next season.
He is scheduled to race in Moto2 and has quickly set his target to be in the top five in the 2020 season with his new team, Angel Nieto.
The 25-year-old rider is bent on putting up a more consistent performance and is still harbouring hopes of returning to MotoGP if given a chance.
“My hope is to do my best. I want to iron out some weaknesses and will try to race in MotoGP in future. For me Moto2 is not so tactically difficult in terms of machines as there are not so many electronic features. I will be giving my competitors a tough race for sure,” he said at a Hi-Rev Dream Chaser media conference with Hafizh Syahrin.
Hafizh has to return to Moto2 with Angel Nieto for 2020 after two seasons in MotoGP after struggling with the switch to KTM machines this season.
The episode saw Hafizh failing to achieve any encouraging results while not being able to tame the machine.
He will however be appearing in his last MotoGP race this season at the Valencian Grand Prix on November 15 to 17 with Red Bull KTM Tech3 before trying out Angel Nieto machines also in Valencia.
“The last race will give me the motivation to do the best for my current team. Even though I have to leave MotoGP, I accept the change and challenge,” he said.
Hafizh started his career as a wildcard rider in 2011 before becoming a full time racer in 2014 in Moto2 and succeeded in finishing as the 10th best rider with several podium appearances in 2016 and 2017.
The Ampang rider became the first Malaysian rider to compete in MotoGP in 2018 when he joined Yamaha Tech3 Racing. — Bernama


The base card styling applies a border and padding to the card.
Cards can be any size and it’s ok to increase the body text size for larger cards.
…
This is a description of the card’s content.
This is a description of the card’s content. Sometimes the description is two or three sentences.
Applying a .bs-*
class adds a box shadow to a card. Useful when giving users the impression they can interact with the card.
This adds a small box shadow.
This adds medium box shadow.
This is the largest box shadow.
The .s-card
class can be applied to an <a>
tag for instances where a whole card should link somewhere. If possible, linked cards should visually indication that they’re interactive (ex. including an .s-btn
or .s-link
somewhere).
A :hover
style for border color is automatically added to all linked cards. For linked cards with a box shadow (.bs-*
), adding a .h:bs-*
class will apply a hover style to the box shadow as well. Increasing the .bs-
size by a factor of one is usually best.
…
…
…
…
{% endhighlight %}This is a description of the card’s content.
Learn more
When vertical space is an issue, the CTA can be moved inline with paragraph text. Learn more
When a card’s content is visually complex (ex. a graph) or having extra decoration is visually distracting.
This is a description of the card’s content.
Learn more
This is a description of the card’s content.
Learn more
This is a description of the card’s content.
Learn more
When a card is disabled or considered completed, apply the muted modifier to visually dim the card.
…
This is a description of the card’s content.
This is a description of the card’s content.
First introduced for our collections feature in Teams, cards can also be stacked to imply multiple sections or items. No need to overthink it, we can just nest our cards. Note: You’ll need to compensate for the 4px
of nesting on that right edge to keep things equidistant.
A collection of various announcements shared across the org.


When surplus PV-power is available, it makes sense for this energy to be used for heating water. A standard immersion heater is not ideal because you are charged for any extra power that it takes. What's needed is a variable resistive load. By rapidly switching a fixed load on & off, a Solid State Relay can reduce the overall power consumption but this will not necessarily prevent the user from being charged. Any meter that continuously monitors voltage & current will not be fooled by a load that is rapidly turned on & off. The meter will accurately record any power that's taken from the grid during the 'on' portions, and will correctly ignore any "reverse energy" that's exported during the periods in-between.
By operating in 'switched mode', a SSR can control large amounts of power without consuming much itself. However, when operated in 'linear mode', a solid-state device dissipates the same amount of energy as if it were a resistive load with a similar voltage drop across its terminals. Being small in size, electronic devices that dissipate energy generally need heat-sinks, and heat-sinks work best when water-cooled.
So, a solid-state device (or an array of them) operating in linear mode with a large heat-sink, all submerged under water would appear to solve the problem. If this analysis is correct, why does no-one supply such a component as a direct replacement for a standard immersion heater?
Or maybe should I be talking to the patent office ...
Re: Heating water with spare PV-power
Experiments with cycling a kettle on & off have shown that a small amount of averaging takes place in our electricity meter. A conventional PWM ac power-controller should therefore be OK for matching the power taken by our immersion heater to the spare PV power that is available. This 'power window' appears to be around 1/1000kWh, so a 'quiet' controller that passes or suppresses entire half-cycles should be fine. My wacky idea of a variable electronic load can now thankfully be consigned to the Recycle bin.
Being able to 'invest and reclaim' one's precious PV-generated energy at the grid point is really neat. In less than ideal weather conditions, my PV system would never be able to power our 3kW immersion heater on its own. The grid is providing an elastic buffer without which our inverter would doubtless complain. It's rather like trying to vault over a high barrier. What's needed is the use of a trampoline, and that's what the grid is providing for free :D
Re: Heating water with spare PV-power
but you do not need 3kw to power your immersion heater. if you put 1kw to the element it will still give you a tank full of hot water, it will just take longer to heat up. On cloudy days my solar immersion conroller gives me a tank of warm water using just 600w at the element.
Re: Heating water with spare PV-power
Madmurg: calypso_rae is referring to the need to have a controller to actually be able to dissipate a variable amount of power into the immersion element. There is a long discussion on controller design on the forum here: http://openenergymonitor.org/emon/node/176
Re: Heating water with spare PV-power
madmurg: but you do not need 3kw to power your immersion heater. if you put 1kw to the element it will still give you a tank full of hot water, it will just take longer to heat up. On cloudy days my solar immersion conroller gives me a tank of warm water using just 600w at the element.
With a 3kW immersion heater, there are only two ways to make it take less than 3kw: one is to reduce the level of its ac supply voltage to it; the other is to switch the 240V supply rapidly on and off. The first approach would require a water-cooled electronic load to be placed in series with the immersion. Thankfully, after doing some tests with a kettle, it seems that such a drastic approach will not be necessary. When my SSR finally appears, I therefore look forward to building a conventional controller whereby selected half-cycles of the mains will be fed to the immersion according to how much spare PV is available.
This approach only works because of the small window of flexibility in our supply meter mains. A free-standing PV system, if generating only 600W, would presumably be unable to power a 3KW load in this way.
Re: Heating water with spare PV-power
I have built a unit for this. In the unit is a Kemo 4Kw Triac controller http://www.kemo-electronic.de/en/Light-Sound/Effects/Modules/M028N-Power-control-110-240-V-AC-4000-VA.php. Connected to that is a PWM controller http://www.kemo-electronic.de/en/Transformer-Dimmer/Converter/M150-DC-pulse-converter.php.
These in the uk are available from Brocott UK on the web; I have done it this way because these modules are available to anyone who is not to good with electronic circuitry building.
I have split my immersion heater MCB off from the main domestic load in it's own small consumer unit.
Also in the unit is a 30A relay that will operate on and off from a small bank of relays (bought on Ebay) also in the unit. The 30A relay is to completely isolate the Triac control unit when not enough energy is available from the solar.
I have fitted a 9 pin rs232 type connector to the aluminum case it is installed in which carries the PWM signal, 12v for the small relays and signals to operate the small relays and a led to indicate when power is on to the controller.
There is an 9 pin RS232 lead linking the two units so basically, the mains is isolated from the low voltage Arduino based unit.
This bit all works fine and I would recommend perhaps to do it this way; I will post a pic of the unit next week.
The only thing I cannot get right is the sketch; I have tried using the example voltage and current sketch on here and installed the Emonlib but the sketch just throws up errors when I compile it. I have a 4 line lcd which i have placed into the separate which works fine and should give me all the information I require. Could someone please, please help me with this?
I am mid 50's and some of the sketch I just don't understand, seems harder to take new things in the older you get.
I suppose you could use the arduino based unit to control a storage heater as well as hot water with another power control unit like I mention before. The immersion heater will switch off when it is hot enough via the thermostat so depending on your PV system some spare energy would be available. Monitor the immersion heater as well via a ct.
Mark.
Re: Heating water with spare PV-power
Once a means has been implemented to prevent surplus power from going back into the grid, that power can be then used for any suitable purpose on-site. On a good day, there should be more than sufficient power to boil up a tankful of DWH, so it makes sense to use any that's left over for heating up a storage heater. For households with combi boilers, i.e. without a DHW tank, one or more storage heaters would seem the obvious way to go.
I'm surprised that you would want to measure the immersion heater's feed with another CT. If you are controlling this supply directly, don't you already know how much power it's getting?
Re: Heating water with spare PV-power
Submitted by calypso_rae on Sat, 21/04/2012 - 22:23.
madmurg: but you do not need 3kw to power your immersion heater. if you put 1kw to the element it will still give you a tank full of hot water, it will just take longer to heat up. On cloudy days my solar immersion conroller gives me a tank of warm water using just 600w at the element.
With a 3kW immersion heater, there are only two ways to make it take less than 3kw: one is to reduce the level of its ac supply voltage to it; the other is to switch the 240V supply rapidly on and off. The first approach would require a water-cooled electronic load to be placed in series with the immersion. Thankfully, after doing some tests with a kettle, it seems that such a drastic approach will not be necessary. When my SSR finally appears, I therefore look forward to building a conventional controller whereby selected half-cycles of the mains will be fed to the immersion according to how much spare PV is available.
This approach only works because of the small window of flexibility in our supply meter mains. A free-standing PV system, if generating only 600W, would presumably be unable to power a 3KW load in this way.
I beg to differ as I have a fully working controller which gives me a tank of hot water everyday without drawing anything from the grid. sometimes if it is cloudy the tank only gets luke warm but on a sunny day it is piping hot. I use a crydom proportional controller to vary the power to the immersion, and it does work with loads as low as 600w.
Re: Heating water with spare PV-power
Well I was thinking that once the water in the Immersion heater tank had got up to temperature and the thermostat had switch off then a CT on the Immersion heater circuit would tell the Arduino to switch excess power to else where such as a small storage heater on another PWM dimmer control such as the one I mentioned from "Kemo".
Re: Heating water with spare PV-power
@markbeal2:
"Well I was thinking that once the water in the Immersion heater tank had got up to temperature and the thermostat had switch off then a CT on the Immersion heater circuit would tell the Arduino to switch excess power to else where ..."
Fair point. When the DHW gets up to temperature, the Arduino needs to be informed of this somehow. Monitoring the current flow in the immersion heater's supply cable would be one way of doing this. Some logic would be needed to distinguish between the absence of flow due to the thermostat turning off, and the absence of spare power when someone switches the kettle on.
@madmurg
I beg to differ as I have a fully working controller which gives me a tank of hot water everyday without drawing anything from the grid. sometimes if it is cloudy the tank only gets luke warm but on a sunny day it is piping hot. I use a crydom proportional controller to vary the power to the immersion, and it does work with loads as low as 600w.
OK, I think our only difference is one of terminology. By switching the controlled output rapidly on and off, I would say that your Crydom is changing the supply rather than the load. But, hey, you have a working system and mine has yet to get off the drawing board ...


Ocean [al36], ocean, in The Inner Sea
Last updated Turn #148
Ocean [al36], ocean, in The Inner Sea
------------------------------------------------------------------------
24: Pleasure Sloop [v5n], ship, 30 hulls, 1 rowing port, 90 sails, arrived
24: from Ocean [al35], owner:
24: Dorothy [v1b], Pen, with one worker, 94 sailors
24: Apollo [b5e], Imperial Empire, with 11 workers, 63 lt. xbowmen,
24: accompanied by:
24: Lutra [a4w], Imperial Empire, with 11 paladins, 19 pikemen
24: Lungor [y4r], Imperial Empire
24: Merbit [e2m], Imperial Empire
24: Pink Blazer [n8e], Imperial Empire
24: Kiki Ghelfond [p2w], Imperial Empire
24: Hera [g3f], Imperial Empire, with three soldiers, 28 pikemen
24: Thor [r4g], Imperial Empire, with 31 pikemen
24: Eos [a2t], Imperial Empire, with ten workers, 48 lt. xbowmen
24: Khaki Blazer [w4j], Imperial Empire, with four soldiers,
24: three pikemen, 24 lt. foot
24: Banian [e7n], Imperial Empire, duke, the High Priest of the
24: Church of Eres [151], with one soldier, ten angels
25: Pleasure Sloop [v5n], ship, 30 hulls, 1 rowing port, 90 sails,
25: departed for Ocean [al37].
Routes leaving Ocean:
North, to Ocean [ak36], 6 days
East, to Ocean [al37], 6 days
South, to Ocean [am36], 6 days
West, to Ocean [al35], 6 days


<Short question>
Context
<Describe the context which makes the question worth.>
Question
<Complete question>
Method
<Describe how I answer the question (references, proofs, etc.).>
Answer
<Answer to the question.>
Related Questions
<Links to other questions.>
Bibliography
- Authors. Title, publication, . doi:xxx


Auth
@objc final public class Auth: NSObject
Represents a step in an authentication flow. Currently all authenication flows only use a single step, so this class is used as a namespace for static atuhentication functions.
Version
1.0.0-
Register a new account with a generated username. This should primarily be used for testing.
A password can optionally be added to the account.
Errors
AuthenticationError
: The provided secret was incorrect.NotAllowedError
: No secret was provided but the server requires one.Version
1.0.0
Declaration
Swift
public class func anonymous( password: String = UUID().uuidString, serverUrl: String, success: SuccessCallback<AuthInfo>? = nil, failure: FailureCallback? = nil)
Parameters
password
The password to use for the account.
serverUrl
The absolute url of the home server.
success
The callback to be executed upon successful login. Receives authentication info. Can be nil.
failure
The callback to be executed upon failed login. Receives failure cause.
-
Authenticate as a guest user with a generated user id. Guest accounts are limited to a subset of the functionality of full acounts.
At the moment guests are only allowed to join rooms where
Room.guestAccess
has been set toGuestAccessRule.open
. They are not allowed to modify the state of a room, but can send messages and setup calls.Guests are also not able to set their avatar or status, but they can set their display name.
Version
1.0.0
Declaration
Swift
public class func guest(serverUrl: String, success: SuccessCallback<AuthInfo>? = nil, failure: FailureCallback? = nil)
Parameters
serverUrl
The absolute url of the home server.
success
The callback to be executed upon successful login. Receives authentication info. Can be nil.
failure
The callback to be executed upon failed login. Receives failure cause.
-
Login a user using username and password.
Version
1.0.0
Declaration
Swift
public class func login( as username: String, password: String, serverUrl: String, success: SuccessCallback<AuthInfo>? = nil, failure: FailureCallback? = nil)
Parameters
username
The username.
password
The password.
serverUrl
The absolute url of the home server.
success
The callback to be executed upon successful login. Receives authentication info.
failure
The callback to be executed upon failed login. Receives failure cause.
-
Register a new user.
A registration secret should be used iff the server is configured to only allow registration using a secret token. The secret token is used to compute an HMAC and is not sent to the server.
Version
1.0.0
Declaration
Swift
public class func register( as username: String, password: String, secret: String? = nil, serverUrl: String, success: SuccessCallback<AuthInfo>? = nil, failure: FailureCallback? = nil)
Parameters
username
The username.
password
The password.
secret
Shared registration secret.
serverUrl
The absolute url of the home server.
success
The callback to be executed upon successful registration. Receives authentication info.
failure
The callback to be executed upon failed registration. Receives failure cause.
-
Set a new password using an existing login session and the old password.
Version
1.0.0
Declaration
Parameters
authInfo
Auth info object.
oldPassword
Old password.
newPassword
New password.
success
The callback to be executed upon successful reset. Receives authentication info.
failure
The callback to be executed upon failed reset. Receives failure cause.


A simple scatterplot, demonstrating how different views of the same Scalar range can be used to plot the data.
Scalar view Default Banded Logarithmic Symmetric Absolute


Language Name
Percentage
Ruby
40%
JavaScript
26%
Shell
5%
Python
5%
PHP
4%
C
4%
Perl
3%
C++
2%
Java
2%
Objective-C
2%
Demo of
Raphaël
—JavaScript Vector Library


|
Nana - a C++ framework project The Programmer's Guide |
|
nana::gui::API::capture_ignore_children Description Enables or disables the captured window whether to redirect the mouse input to its children when the mouse is over its children. Prototype void capture_ignore_children(bool ignore); Parameters ignore: indicates whether to ignore the redirection of mouse input to its children window when the mouse is over its children. Return Value None. Remarks None. See also capture_window. Move to The Nana Programmer's Guide Application Programming Interface Overviews |


As a part of Devember 2015 this is a simple prototype for testing out both the workflow for a simple puzzle game using the TypeScript port of the "engine" that I use to prototype games, as well as for testing out the sort of logic that is needed for a Dr. Mario type game.
This is a semi-workable demo that shows off a title screen, the core game play mechanics and a game over screen. The graphics are a little crude but workable. This would need more work to become a full fledged game, naturally.
This prototype uses the following music:
"BitQuest"
"Mellowtron"
"Pixelland"
All by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0
http://creativecommons.org/licenses/by/3.0/