BIRD NAMES DICTIONARY
Bird Names Dictionary is the best mobile application for searching bird names in different languages. Application includes over 10 000 bird species with over 20 languages.
Bird Names Dictionary is the best mobile application for searching bird names in different languages. Application includes over 10 000 bird species with over 20 languages.
Over 20 different languages
(* some languages cover the bird species only partially).
Search and filter
Mark your favorite species for filtering. Search by any keyword. Arrange the lists alphabetically or taxonomically. No internet connection required as the whole database resides locally in your device.
Portrait + landscape
Like to use the phone in landscape orientation? We got you covered. Additionally plus-sized iPhones will offer an exclusive split screen view in landscape orientation.
iPad optimised
Naturally.
Any questions about the app?
Don't hesitate to send an email:
treecreeper.productions (at) protonmail (dot) com


To see the calls the ID5 API makes, open Developer Tools in your browser and go to the Network tab. Filter
for id5-sync.com
and you will see the http requests it makes.
An image with the ID5 Universal ID will display in the box below when it is available:


This endpoint provides a list of GitHub's IP addresses. For more information, see "About GitHub's IP addresses."
GET /meta
Status: 200 OK
{
"verifiable_password_authentication": true,
"ssh_key_fingerprints": {
"MD5_RSA": "16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48",
"MD5_DSA": "ad:1c:08:a4:40:e3:6f:9c:f5:66:26:5d:4b:33:5d:8c",
"SHA256_RSA": "nThbg6kXUpJWGl7E1IGOCspRomTxdCARLviKw6E5SY8",
"SHA256_DSA": "br9IjFspm1vxR3iA35FWE+4VTyz1hYVLIE2t1/CeyWQ"
},
"hooks": [
"<IP_ADDRESS>/22"
],
"web": [
"<IP_ADDRESS>/22",
"<IP_ADDRESS>/22"
],
"api": [
"<IP_ADDRESS>/22",
"<IP_ADDRESS>/22"
],
"git": [
"<IP_ADDRESS>/22"
],
"pages": [
"<IP_ADDRESS>/32",
"<IP_ADDRESS>/32"
],
"importer": [
"<IP_ADDRESS>",
"<IP_ADDRESS>"
]
}
| Name | Type | Description |
|---|---|---|
verifiable_password_authentication |
boolean |
Whether authentication with username and password is supported. |
ssh_key_fingerprints |
string |
GitHub's public key fingerprints and SHA256 hashes. For more information, see "GitHub's SSH key fingerprints" in the GitHub Help documentation. |
hooks |
array of strings
|
An Array of IP addresses in CIDR format specifying the addresses that incoming webhooks will originate from on GitHub.com. |
web |
array of strings
|
An Array of IP addresses in CIDR format specifying the Web servers for GitHub.com. |
api |
array of strings
|
An Array of IP addresses in CIDR format specifying the API servers for api.github.com. |
git |
array of strings
|
An Array of IP addresses in CIDR format specifying the Git servers for GitHub.com. |
pages |
array of strings
|
An Array of IP addresses in CIDR format specifying the A records for GitHub Pages. |
importer |
array of strings
|
An Array of IP addresses specifying the addresses that source imports will originate from on GitHub.com. |


| Class | Barby::Barcode |
| In: |
lib/barby/barcode.rb
|
| Parent: | Object |
The base class for all barcodes. It includes some method_missing magic that is used to find registered outputters.
The only interface requirement of a barcode class is that is has an encoding method that returns a string consisting of 1s and 0s representing the barcode‘s "black" and "white" parts. One digit is the width of the "X dimension"; that is, "101100" represents a single-width bar followed by a single-width space, then a bar and a space twice that width.
Example implementation:
class StaticBarcode < Barby::Barcode1D def encoding '101100111000111100001' end end require 'barby/outputter/ascii_outputter' puts StaticBarcode.new.to_ascii(:height => 3) # ## ### #### # # ## ### #### # # ## ### #### #
2D implementation:
class Static2DBarcode < Barby::Barcode2D def encoding ['1010101', '010101110', '0001010100'] end end
Registers an outputter with name so that a call to name on a Barcode instance will be delegated to this outputter
Every barcode must have an encoding method. This method returns a string containing a series of 1 and 0, representing bars and spaces. One digit is the width of one "module" or X dimension.
If the barcode is 2D, it returns an array of strings representing each line in the barcode


We're sorry, but something went wrong!
Our team has been notified and are working on getting it sorted!
Home


in
Everything
Books & Magazines
Games & Computer
Anime & Toys
Bento & Kitchen
Snacks & Food
Traditional & Study
Apparel & Cosplay
Customer information
Enter your name, billing address and email on this page.
Name
Please enter your real name.
First
Last
Billing Address
Your billing address. You can specify a shipping address later.
Street Address
City
State / Province / Region
Postal / Zip Code
Afghanistan
Albania
Algeria
American Samoa
Andorra
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
Cyprus
Czech Republic
Denmark
Djibouti
Dominica
Dominican Republic
East Timor
Ecuador
Egypt
El Salvador
England
Equatorial Guinea
Eritrea
Espana
Estonia
Ethiopia
Falkland Islands
Faroe Islands
Fiji
Finland
France
French Guiana
French Polynesia
French Southern Territories
Gabon
Gambia
Georgia
Germany
Ghana
Gibraltar
Great Britain
Greece
Greenland
Grenada
Guadeloupe
Guam
Guatemala
Guinea
Guinea-Bissau
Guyana
Haiti
Heard and Mc Donald Islands
Honduras
Hong Kong
Hungary
Iceland
India
Indonesia
Iraq
Ireland
Israel
Italy
Jamaica
Japan
Jordan
Kazakhstan
Kenya
Kiribati
Korea, People's Republic of
Korea (South)
Kuwait
Kyrgyzstan
Lao People's Democratic Republic
Latvia
Lebanon
Lesotho
Liberia
Libya
Liechtenstein
Lithuania
Luxembourg
Macau
Macedonia
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 Ireland
Northern Mariana Islands
Norway
Oman
Pakistan
Palau
Panama
Papua New Guinea
Paraguay
Peru
Philippines
Pitcairn
Poland
Portugal
Puerto Rico
Qatar
Reunion
Romania
Russia
Russian Federation
Rwanda
Saint Kitts and Nevis
Saint Lucia
Saint Vincent and the Grenadines
Samoa (Independent)
San Marino
Sao Tome and Principe
Saudi Arabia
Scotland
Senegal
Serbia and Montenegro
Seychelles
Sierra Leone
Singapore
Slovakia
Slovenia
Solomon Islands
Somalia
South Africa
South Georgia and the South Sandwich Islands
South Korea
Spain
Sri Lanka
St. Helena
St. Pierre and Miquelon
Suriname
Svalbard and Jan Mayen Islands
Swaziland
Sweden
Switzerland
Taiwan
Tajikistan
Tanzania
Thailand
Togo
Tokelau
Tonga
Trinidad
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
Vatican City State (Holy See)
Venezuela
Viet Nam
Virgin Islands (British)
Virgin Islands (U.S.)
Wales
Wallis and Futuna Islands
Western Sahara
Yemen
Yugoslavia
Zambia
Zimbabwe
Country
Phone (optional)
Email Address
This will be your contact email address for order status update, newsletter and more.
Choose a password
Enter a password
Retype your password
Where did you hear about J-List/JBOX?
Don't Know!
3yen.org
4chan.org
Anime Insider
Anime or Comic Convention
Clone Army Manga
Danbooru
Dannychoo.com
Facebook
Froogle / Google Products
Geek Monthly
Giant Robot
Google Search
J-List Theatre Manga
Newtype USA
Nyaa
Otaku USA
PiQ Magazine
Play Magazine
Protoculture Addicts
Sci-Fi Magazine
Something Awful
Sankaku Complex
Track-shun.tv Podcast
Tumblr
Twitter
Word of Mouth
Other
If other, please specify


Fill in all the required fields and click Create/Update button to create or update your character options.
Click Done button to proceed to next page in order to take your new created quiz.
Click Reset button to reset all information that you've just typed in the required fields.


This section describes how to import plain text data into Proximity. Proximity lets you import a complete database, including any subgraphs and containers, or you can import individual attributes or containers.
|
The utilities that use the Proximity plain text data format perform no error checking. Proximity makes no checks to ensure that attributes are assigned to items (objects, links, subgraphs, or containers) that are actually present in the database. Assigning attribute values to non-existent items does not trigger an exception or warning. No checks are made to ensure that existing data is not being incorrectly overwritten. Although this format requires less disc space than the XML format and its use can improve import and export speed, you are solely responsible for maintaining data integrity and consistency when using this format. |
Unlike when using the XML data format, Proximity does not
prohibit adding additional elements to a database once those elements
have been defined when importing data using the plain text data
format. Therefore, there is no need for a equivalent to the
noChecks
option available for importing XML data. When
using the plain text format, you must take care to ensure the
integrity and consistency of your data; Proximity will not necessarily
alert you to data errors when using this format.
The exercise below walks through the process of importing a sample database using the plain text data format. This database stores selected data for a small set of movies, actors, and directors. The set of files for this exercise illustrate how the plain text data format represents all types of Proximity database entities.
Exercise 3.6. Importing a database using plain text data:
This exercise and exercise Exercise 3.7 use a different database than that used for most Tutorial exercises. Before beginning these exercises, make sure that you are no longer serving the ProxWebKB database. Data files must be on the same machine as that serving the database.
Uncompress the plain text data files.
>cd $PROX_HOME/doc/user/tutorial/examples
>gunzip movie_db.tar.gz
Uncompressing this tar file creates a
MovieDB
directory under the
$PROX_HOME/doc/user/tutorial/examples
directory. All plain text data files required for the current import
operation must be located in the same directory.
Start the MonetDB server. Data files must be on the same machine as that serving the database.
> Mserver --dbname MovieDB $PROX_HOME/resources/init-mserver.mil
The init-mserver.mil
script sets the port
for the server to 30000.
Remember to use a port number > 40000 if you are using
MonetDB 4.6.2. See
“Running the MonetDB database server” for more
information.
Because the database does not exist, MonetDB prints warning statements along with its usual startup message:
!WARNING: GDKlockHome: created directory /usr/local/Monet-mars/var/MonetDB/dbfarm/MovieDB/ !WARNING: GDKlockHome: ignoring empty or invalid .gdk_lock. !WARNING: BBPdir: initializing BBP. # MonetDB Server v4.20.0 # based on GDK v1.20.0 # Copyright (c) 1993-2007, CWI. All rights reserved. # Compiled for powerpc-apple-darwin8.10.0/32bit with 32bit OIDs; dynamically linked. # Visit http://monetdb.cwi.nl/ for further information. Listening on port 30000 MonetDB>
The startup message may be slightly different depending on your operating system and the version of MonetDB you are using.
MonetDB also creates a MovieDB
directory in its
dbfarm
directory to hold the new database.
Leave the MonetDB server running for the remainder of the import process. You must be serving the database for any Proximity action that interacts with database data.
Initialize the new Proximity database. (Substitute the appropriate port number if you are using a different port.)
>cd $PROX_HOME
>bin/db-util.sh localhost:30000 init-db
Proximity outputs the following trace (leading information showing elapsed time and execution thread has been omitted from the trace for brevity):
INFO app.DBUtil: * connecting to db INFO app.DBUtil: * database opened; initializing Prox tables INFO db.DB: * initializing Proximity database INFO app.DBUtil: * tables initialized INFO app.DBUtil: * disconnecting from db INFO app.DBUtil: * done
Import the plain text data file into the new Proximity database. (Substitute the appropriate port number if you are using a different port.)
> bin/import-text.sh localhost:30000 \
$PROX_HOME/doc/user/tutorial/examples/MovieDB
The plain text data files must be on the same machine as that serving the (still empty) database. You must provide an absolute path to the data files; relative paths cannot be used.
During import, Proximity reports on the entities being defined (leading information showing elapsed time and execution thread has been omitted from the trace for brevity):
INFO app.ImportTextApp: * importing database from /proximity/doc/user/tutorial/examples/MovieDB INFO app.ImportTextApp: Loading object table INFO app.ImportTextApp: Loading link table INFO app.ImportTextApp: Loading attributes INFO app.ImportTextApp: Loading attribute: O_attr_objtype.data INFO app.ImportTextApp: Loading attribute: O_attr_title.data INFO app.ImportTextApp: Loading attribute: O_attr_name.data INFO app.ImportTextApp: Loading attribute: L_attr_linktype.data INFO app.ImportTextApp: Loading attribute: C_attr_qgraph_query.data INFO app.ImportTextApp: Loading containers INFO app.ImportTextApp: Loading container: si_0 INFO app.ImportTextApp: Loading container attribute: si_0_attr_samplenumber.data INFO app.ImportTextApp: Loading container: si_1 INFO app.ImportTextApp: Loading container: si_2 INFO app.ImportTextApp: Loading container: si_3 INFO app.ImportTextApp: * done importing


| | |
- build_AE(e, d, opt='adam', l='mse')
- Autoencoder
:param e: Model of encoder
:param d: Model of decoder
:param opt: either optimizer or string
:param l: loss function
:return: Return the compiled model.
- build_GAN(e, d, opt='adam', l='binary_crossentropy')
- build_decoder(encoded)
- Decoder
:param encoded: the layer that is the input of the decoder (typically the encoded layer from the encoder)
:return: returns "input_code" wich is the input layer, "decoded" which is the last layer, and the model.
- build_discriminator(shape)
- discriminator so tell if an image is real or fake.
:param shape: tuple containing the sape if the input, usually the shape of the image
:return: model outputting true/false
- build_encoder(img_shape)
- Encoder
This encoder is suposed to be used for the GAN, but is trained with an AE
Important, image is in the range -1->1 so tanh is better.
https://github.com/soumith/ganhacks talks about not using 0->1
:param img_shape: The shape of the input image as a tuple containing shape
:return: returns "input_img" wich is the input layer, "encoded" which is the last layer, and the model.
|


- Please add the days of rent in the Quantity field for the rented cars. Also, add the quantity of cars you want to buy in the Quantity field.
- Click the "X" next to any item to remove it from your cart
Your Cart
| Remove | Car | Production Year | Quantity | Total Price |
|---|---|---|---|---|
| Total |


| adaptiveRegress | High/Low binary partition by adaptive regression. |
| dcorMatrix | Compute Distance Correlation Matrix. |
| dcorMatrixNA | Compute Distance Correlation Matrix with Missing Values in Data. |
| dcorSingle | Single Pair Distance Correlation. |
| gsplom | Glyph SPLOM Workflow Wrapper |
| gsplomCore | Glyph SPLOM Workflow Wrapper |
| gsplomPlot | Glyph SPLOM Workflow Wrapper |
| logicClassMatrix | Compute Logical Dependency Class Matrix. |


Endpoint management definitions for the Atmel AVR8 architecture.
More...
Functions, macros and enums related to endpoint management when in USB Device mode. This module contains the endpoint management macros, as well as endpoint interrupt and data send/receive functions for various data types.
◆ ENDPOINT_BANK_DOUBLE
| #define ENDPOINT_BANK_DOUBLE (1 << EPBK0) |
Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates that the endpoint should have two banks, which requires more USB FIFO memory but results in faster transfers as one USB device (the AVR or the host) can access one bank while the other accesses the second bank.
◆ ENDPOINT_BANK_SINGLE
| #define ENDPOINT_BANK_SINGLE (0 << EPBK0) |
Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates that the endpoint should have one single bank, which requires less USB FIFO memory but results in slower transfers as only one USB device (the AVR or the host) can access the endpoint's bank at the one time.
◆ ENDPOINT_BANKS_SUPPORTED
| #define ENDPOINT_BANKS_SUPPORTED |
( |
|
EPIndex | ) |
_ENDPOINT_GET_BANKS(EPIndex) |
Retrieves the total number of banks supported by the given endpoint.
- Note
- This macro will only work correctly on endpoint indexes that are compile-time constants defined by the preprocessor.
- Parameters
-
◆ ENDPOINT_CONTROLEP_DEFAULT_SIZE
| #define ENDPOINT_CONTROLEP_DEFAULT_SIZE 8 |
Default size of the default control endpoint's bank, until altered by the control endpoint bank size value in the device descriptor. Not available if the FIXED_CONTROL_ENDPOINT_SIZE
token is defined.
◆ ENDPOINT_MAX_SIZE
| #define ENDPOINT_MAX_SIZE |
( |
|
EPIndex | ) |
_ENDPOINT_GET_MAXSIZE(EPIndex) |
Retrieves the maximum bank size in bytes of a given endpoint.
- Note
- This macro will only work correctly on endpoint indexes that are compile-time constants defined by the preprocessor.
- Parameters
-
◆ ENDPOINT_TOTAL_ENDPOINTS
| #define ENDPOINT_TOTAL_ENDPOINTS ENDPOINT_DETAILS_MAXEP |
Total number of endpoints (including the default control endpoint at address 0) which may be used in the device. Different USB AVR models support different amounts of endpoints, this value reflects the maximum number of endpoints for the currently selected AVR model.
◆ Endpoint_ClearStatusStage()
| void Endpoint_ClearStatusStage |
( |
void |
| ) |
|
Completes the status stage of a control transfer on a CONTROL type endpoint automatically, with respect to the data direction. This is a convenience function which can be used to simplify user control request handling.
◆ Endpoint_ConfigureEndpoint()
| static bool Endpoint_ConfigureEndpoint |
( |
const uint8_t |
Number, |
|
|
const uint8_t |
Type, |
|
|
const uint8_t |
Direction, |
|
|
const uint16_t |
Size, |
|
|
const uint8_t |
Banks |
|
) |
| |
|
inlinestatic |
Configures the specified endpoint number with the given endpoint type, direction, bank size and banking mode. Once configured, the endpoint may be read from or written to, depending on its direction.
- Parameters
-
| [in] | Number | Endpoint number to configure. This must be more than 0 and less than ENDPOINT_TOTAL_ENDPOINTS. |
| [in] | Type | Type of endpoint to configure, a EP_TYPE_* mask. Not all endpoint types are available on Low Speed USB devices - refer to the USB 2.0 specification. |
| [in] | Direction | Endpoint data direction, either ENDPOINT_DIR_OUT or ENDPOINT_DIR_IN. All endpoints (except Control type) are unidirectional - data may only be read from or written to the endpoint bank based on its direction, not both. |
| [in] | Size | Size of the endpoint's bank, where packets are stored before they are transmitted to the USB host, or after they have been received from the USB host (depending on the endpoint's data direction). The bank size must indicate the maximum packet size that the endpoint can handle. |
| [in] | Banks | Number of banks to use for the endpoint being configured, an ENDPOINT_BANK_* mask. More banks uses more USB DPRAM, but offers better performance. Isochronous type endpoints must have at least two banks. |
- Note
- When the
ORDERED_EP_CONFIG
compile time option is used, Endpoints must be configured in ascending order, or bank corruption will occur.
-
Different endpoints may have different maximum packet sizes based on the endpoint's index - refer to the chosen microcontroller model's datasheet to determine the maximum bank size for each endpoint.
-
The default control endpoint should not be manually configured by the user application, as it is automatically configured by the library internally.
-
This routine will automatically select the specified endpoint upon success. Upon failure, the endpoint which failed to reconfigure correctly will be selected.
- Returns
- Boolean
true
if the configuration succeeded, false
otherwise.
◆ Endpoint_DisableEndpoint()
| static void Endpoint_DisableEndpoint |
( |
void |
| ) |
|
|
inlinestatic |
Disables the currently selected endpoint so that data cannot be sent and received through it to and from a host.
◆ Endpoint_EnableEndpoint()
| static void Endpoint_EnableEndpoint |
( |
void |
| ) |
|
|
inlinestatic |
Enables the currently selected endpoint so that data can be sent and received through it to and from a host.
- Note
- Endpoints must first be configured properly via Endpoint_ConfigureEndpoint().
◆ Endpoint_GetCurrentEndpoint()
| static uint8_t Endpoint_GetCurrentEndpoint |
( |
void |
| ) |
|
|
inlinestatic |
Get the endpoint address of the currently selected endpoint. This is typically used to save the currently selected endpoint number so that it can be restored after another endpoint has been manipulated.
- Returns
- Index of the currently selected endpoint.
◆ Endpoint_GetEndpointDirection()
| static uint8_t Endpoint_GetEndpointDirection |
( |
void |
| ) |
|
|
inlinestatic |
Determines the currently selected endpoint's direction.
- Returns
- The currently selected endpoint's direction, as a
ENDPOINT_DIR_*
mask.
◆ Endpoint_GetEndpointInterrupts()
| static uint8_t Endpoint_GetEndpointInterrupts |
( |
void |
| ) |
|
|
inlinestatic |
Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their interrupt duration has elapsed. Which endpoints have interrupted can be determined by masking the return value against (1 << {Endpoint Number})
.
- Returns
- Mask whose bits indicate which endpoints have interrupted.
◆ Endpoint_HasEndpointInterrupted()
| static bool Endpoint_HasEndpointInterrupted |
( |
const uint8_t |
EndpointNumber | ) |
|
|
inlinestatic |
Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type endpoints).
- Parameters
-
| [in] | EndpointNumber | Index of the endpoint whose interrupt flag should be tested. |
- Returns
- Boolean
true
if the specified endpoint has interrupted, false
otherwise.
◆ Endpoint_IsConfigured()
| static bool Endpoint_IsConfigured |
( |
void |
| ) |
|
|
inlinestatic |
Determines if the currently selected endpoint is configured.
- Returns
- Boolean
true
if the currently selected endpoint has been configured, false
otherwise.
◆ Endpoint_IsEnabled()
| static bool Endpoint_IsEnabled |
( |
void |
| ) |
|
|
inlinestatic |
Determines if the currently selected endpoint is enabled, but not necessarily configured.
- Returns
- Boolean
true
if the currently selected endpoint is enabled, false
otherwise.
◆ Endpoint_ResetDataToggle()
| static void Endpoint_ResetDataToggle |
( |
void |
| ) |
|
|
inlinestatic |
Resets the data toggle of the currently selected endpoint.
◆ Endpoint_ResetEndpoint()
| static void Endpoint_ResetEndpoint |
( |
const uint8_t |
EndpointNumber | ) |
|
|
inlinestatic |
Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's data In and Out pointers to the bank's contents.
- Parameters
-
| [in] | EndpointNumber | Endpoint number whose FIFO buffers are to be reset. |
◆ Endpoint_SelectEndpoint()
| static void Endpoint_SelectEndpoint |
( |
const uint8_t |
EndpointNumber | ) |
|
|
inlinestatic |
Selects the given endpoint number. If the address from the device descriptors is used, the value should be masked with the ENDPOINT_EPNUM_MASK constant to extract only the endpoint number (and discarding the endpoint direction bit).
Any endpoint operations which do not require the endpoint number to be indicated will operate on the currently selected endpoint.
- Parameters
-
| [in] | EndpointNumber | Endpoint number to select. |
◆ Endpoint_SetEndpointDirection()
| static void Endpoint_SetEndpointDirection |
( |
const uint8_t |
DirectionMask | ) |
|
|
inlinestatic |
Sets the direction of the currently selected endpoint.
- Parameters
-
| [in] | DirectionMask | New endpoint direction, as a ENDPOINT_DIR_* mask. |
◆ USB_Device_ControlEndpointSize
| uint8_t USB_Device_ControlEndpointSize |
Global indicating the maximum packet size of the default control endpoint located at address 0 in the device. This value is set to the value indicated in the device descriptor in the user project once the USB interface is initialized into device mode.
If space is an issue, it is possible to fix this to a static value by defining the control endpoint size in the FIXED_CONTROL_ENDPOINT_SIZE
token passed to the compiler in the makefile via the -D switch. When a fixed control endpoint size is used, the size is no longer dynamically read from the descriptors at runtime and instead fixed to the given value. When used, it is important that the descriptor control endpoint size value matches the size given as the FIXED_CONTROL_ENDPOINT_SIZE
token - it is recommended that the FIXED_CONTROL_ENDPOINT_SIZE
token be used in the device descriptors to ensure this.
- Note
- This variable should be treated as read-only in the user application, and never manually changed in value.


This is colorful header
This is colorful header with class
This is colorful header with id
This is colorful header with id and a class
2 selector 1 rule
Only bold
Bold and text size
Party fiesta


{% extends 'layout-2-1-bleedbar.html' %} {% block meta_viewport %} {{ super() }} {% endblock %} {% block title -%} Privacy Act Statement {%- endblock %} {% block desc -%} The Privacy Act statement for the CFPB’s voluntary diversity assessment onboarding form. {%- endblock %} {% block og_desc -%} The Privacy Act statement for the CFPB’s voluntary diversity assessment onboarding form. {%- endblock %} {% block css %} {{ super() }} {% endblock %} {% block content_main %}
5 U.S.C. 552a(e)(3)
The information that you provide may be used by the Consumer Financial Protection Bureau (Bureau) to monitor progress and trends in the financial services industry with regard to diversity and inclusion in employment and contracting activities and to identify and highlight those policies and practices that have been successful. Personally identifiable information (PII) such as name, email, and phone number is collected from individuals that submit the survey on behalf of their entity.
Information collected will be treated in accordance with the System of Records Notice (“SORN”), CFPB.0013 External Contact Database, 77 FR 2689. The Bureau may publish information disclosed by the entity, such as any identified leading practices, in any form that does not identify a particular entity or individual or disclose confidential business information. The collection of this information is authorized by Public Law No. 111-203, Title III, Section 342 codified at 12 U.S.C. 5452. Participation in this survey is voluntary.


zoo.feature.image package¶
Submodules¶
zoo.feature.image.imagePreprocessing module¶
-
class
zoo.feature.image.imagePreprocessing.
ImageAspectScale
(min_size, scale_multiple_of=1, max_size=1000, resize_mode=1, use_scale_factor=True, min_scale=-1.0, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Resize the image, keep the aspect ratio. scale according to the short edge :param min_size scale size, apply to short edge :param scale_multiple_of make the scaled size multiple of some value :param max_size max size after scale :param resize_mode if resizeMode = -1, random select a mode from (Imgproc.INTER_LINEAR, Imgproc.INTER_CUBIC, Imgproc.INTER_AREA, Imgproc.INTER_NEAREST, Imgproc.INTER_LANCZOS4) :param use_scale_factor if true, scale factor fx and fy is used, fx = fy = 0 :aram min_scale control the minimum scale up for image
-
class
zoo.feature.image.imagePreprocessing.
ImageBrightness
(delta_low, delta_high, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
adjust the image brightness :param deltaLow brightness parameter: low bound :param deltaHigh brightness parameter: high bound
-
class
zoo.feature.image.imagePreprocessing.
ImageBytesToMat
(byte_key='bytes', image_codec=-1, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Transform byte array(original image file in byte) to OpenCVMat :param byte_key key that maps byte array :param image_codec specifying the color type of a loaded image, same as in OpenCV.imread. By default is Imgcodecs.CV_LOAD_IMAGE_UNCHANGED
-
class
zoo.feature.image.imagePreprocessing.
ImageCenterCrop
(crop_width, crop_height, is_clip=True, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Crop a cropWidth x cropHeight patch from center of image. The patch size should be less than the image size. :param crop_width width after crop :param crop_height height after crop :param is_clip clip cropping box boundary
-
class
zoo.feature.image.imagePreprocessing.
ImageChannelNormalize
(mean_r, mean_g, mean_b, std_r=1.0, std_g=1.0, std_b=1.0, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
image channel normalize :param mean_r mean value in R channel :param mean_g mean value in G channel :param meanB_b mean value in B channel :param std_r std value in R channel :param std_g std value in G channel :param std_b std value in B channel
-
class
zoo.feature.image.imagePreprocessing.
ImageChannelOrder
(bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
random change the channel of an image
-
class
zoo.feature.image.imagePreprocessing.
ImageColorJitter
(brightness_prob=0.5, brightness_delta=32.0, contrast_prob=0.5, contrast_lower=0.5, contrast_upper=1.5, hue_prob=0.5, hue_delta=18.0, saturation_prob=0.5, saturation_lower=0.5, saturation_upper=1.5, random_order_prob=0.0, shuffle=False, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Random adjust brightness, contrast, hue, saturation :param brightness_prob probability to adjust brightness :param brightness_delta brightness parameter :param contrast_prob probability to adjust contrast :param contrast_lower contrast lower parameter :param contrast_upper contrast upper parameter :param hue_prob probability to adjust hue :param hue_delta hue parameter :param saturation_prob probability to adjust saturation :param saturation_lower saturation lower parameter :param saturation_upper saturation upper parameter :param random_order_prob random order for different operation :param shuffle shuffle the transformers
-
class
zoo.feature.image.imagePreprocessing.
ImageExpand
(means_r=123, means_g=117, means_b=104, min_expand_ratio=1.0, max_expand_ratio=4.0, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
expand image, fill the blank part with the meanR, meanG, meanB
:param means_r means in R channel :param means_g means in G channel :param means_b means in B channel :param min_expand_ratio min expand ratio :param max_expand_ratio max expand ratio
-
class
zoo.feature.image.imagePreprocessing.
ImageFeatureToTensor
(bigdl_type='float')[source]¶ Bases:
zoo.feature.common.Preprocessing
a Transformer that convert ImageFeature to a Tensor.
-
class
zoo.feature.image.imagePreprocessing.
ImageFiller
(start_x, start_y, end_x, end_y, value=255, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Fill part of image with certain pixel value :param start_x start x ratio :param start_y start y ratio :param end_x end x ratio :param end_y end y ratio :param value filling value
-
class
zoo.feature.image.imagePreprocessing.
ImageFixedCrop
(x1, y1, x2, y2, normalized=True, is_clip=True, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Crop a fixed area of image
:param x1 start in width :param y1 start in height :param x2 end in width :param y2 end in height :param normalized whether args are normalized, i.e. in range [0, 1] :param is_clip whether to clip the roi to image boundaries
-
class
zoo.feature.image.imagePreprocessing.
ImageHFlip
(bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Flip the image horizontally
-
class
zoo.feature.image.imagePreprocessing.
ImageHue
(delta_low, delta_high, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
adjust the image hue :param deltaLow hue parameter: low bound :param deltaHigh hue parameter: high bound
-
class
zoo.feature.image.imagePreprocessing.
ImageMatToTensor
(to_RGB=False, tensor_key='imageTensor', share_buffer=True, format='NCHW', bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
MatToTensor :param toRGB BGR to RGB (default is BGR) :param tensorKey key to store transformed tensor :param format DataFormat.NCHW or DataFormat.NHWC
-
class
zoo.feature.image.imagePreprocessing.
ImagePixelNormalize
(means, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Pixel level normalizer, data(i) = data(i) - mean(i)
:param means pixel level mean, following H * W * C order
-
class
zoo.feature.image.imagePreprocessing.
ImagePreprocessing
(bigdl_type='float', *args)[source]¶ Bases:
zoo.feature.common.Preprocessing
ImagePreprocessing is a transformer that transform ImageFeature
-
class
zoo.feature.image.imagePreprocessing.
ImageRandomAspectScale
(scales, scale_multiple_of=1, max_size=1000, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
resize the image by randomly choosing a scale :param scales array of scale options that for random choice :param scaleMultipleOf Resize test images so that its width and height are multiples of :param maxSize Max pixel size of the longest side of a scaled input image
-
class
zoo.feature.image.imagePreprocessing.
ImageRandomCrop
(crop_width, crop_height, is_clip=True, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Random crop a cropWidth x cropHeight patch from an image. The patch size should be less than the image size.
:param crop_width width after crop :param crop_height height after crop :param is_clip whether to clip the roi to image boundaries
-
class
zoo.feature.image.imagePreprocessing.
ImageRandomPreprocessing
(preprocessing, prob, bigdl_type='float')[source]¶ Bases:
zoo.feature.common.Preprocessing
Randomly apply the preprocessing to some of the input ImageFeatures, with probability specified. E.g. if prob = 0.5, the preprocessing will apply to half of the input ImageFeatures. :param preprocessing preprocessing to apply. :param prob probability to apply the preprocessing action.
-
class
zoo.feature.image.imagePreprocessing.
ImageResize
(resize_h, resize_w, resize_mode=1, use_scale_factor=True, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Resize image :param resize_h height after resize :param resize_w width after resize :param resize_mode if resizeMode = -1, random select a mode from (Imgproc.INTER_LINEAR, Imgproc.INTER_CUBIC, Imgproc.INTER_AREA, Imgproc.INTER_NEAREST, Imgproc.INTER_LANCZOS4) :param use_scale_factor if true, scale factor fx and fy is used, fx = fy = 0 note that the result of the following are different Imgproc.resize(mat, mat, new Size(resizeWH, resizeWH), 0, 0, Imgproc.INTER_LINEAR) Imgproc.resize(mat, mat, new Size(resizeWH, resizeWH))
-
class
zoo.feature.image.imagePreprocessing.
ImageSaturation
(delta_low, delta_high, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
adjust the image Saturation :param deltaLow brightness parameter: low bound :param deltaHigh brightness parameter: high bound
-
class
zoo.feature.image.imagePreprocessing.
ImageSetToSample
(input_keys=['imageTensor'], target_keys=None, sample_key='sample', bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
transform imageframe to samples :param input_keys keys that maps inputs (each input should be a tensor) :param target_keys keys that maps targets (each target should be a tensor) :param sample_key key to store sample
-
class
zoo.feature.image.imagePreprocessing.
PerImageNormalize
(min, max, norm_type=32, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imagePreprocessing.ImagePreprocessing
Normalizes the norm or value range per image, similar to opencv::normalize https://docs.opencv.org/ref/master/d2/de8/group__core__array.html #ga87eef7ee3970f86906d69a92cbf064bd ImageNormalize normalizes scale and shift the input features. Various normalize methods are supported, Eg. NORM_INF, NORM_L1, NORM_L2 or NORM_MINMAX Pleas notice it’s a per image normalization. :param min lower range boundary in case of the range normalization or norm value to normalize :param max upper range boundary in case of the range normalization. It is not used for the norm normalization. :param norm_type normalization type, see opencv:NormTypes. https://docs.opencv.org/ref/master/d2/de8/group__core__array.html #gad12cefbcb5291cf958a85b4b67b6149f Default Core.NORM_MINMAX
-
class
zoo.feature.image.imagePreprocessing.
RowToImageFeature
(bigdl_type='float')[source]¶ Bases:
zoo.feature.common.Preprocessing
a Transformer that converts a Spark Row to a BigDL ImageFeature.
zoo.feature.image.imageset module¶
-
class
zoo.feature.image.imageset.
DistributedImageSet
(image_rdd=None, label_rdd=None, jvalue=None, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imageset.ImageSet
DistributedImageSet wraps an RDD of ImageFeature
-
class
zoo.feature.image.imageset.
ImageSet
(jvalue, bigdl_type='float')[source]¶ Bases:
bigdl.util.common.JavaValue
ImageSet wraps a set of ImageFeature
-
classmethod
read
(path, sc=None, min_partitions=1, resize_height=-1, resize_width=-1, image_codec=-1, bigdl_type='float')[source]¶ Read images as Image Set if sc is defined, Read image as DistributedImageSet from local file system or HDFS if sc is null, Read image as LocalImageSet from local file system :param path path to read images if sc is defined, path can be local or HDFS. Wildcard character are supported. if sc is null, path is local directory/image file/image file with wildcard character :param sc SparkContext :param min_partitions A suggestion value of the minimal splitting number for input data. :param resize_height height after resize, by default is -1 which will not resize the image :param resize_width width after resize, by default is -1 which will not resize the image :param image_codec specifying the color type of a loaded image, same as in OpenCV.imread. By default is Imgcodecs.CV_LOAD_IMAGE_UNCHANGED(-1) :return ImageSet
-
classmethod
-
class
zoo.feature.image.imageset.
LocalImageSet
(image_list=None, label_list=None, jvalue=None, bigdl_type='float')[source]¶ Bases:
zoo.feature.image.imageset.ImageSet
LocalImageSet wraps a list of ImageFeature


Python types intro
Python 3.6+ has support for optional "type hints".
These "type hints" are a new syntax (since Python 3.6+) that allow declaring the type of a variable.
By declaring types for your variables, editors and tools can give you better support.
This is just a quick tutorial / refresher about Python type hints. It covers only the minimum necessary to use them with FastAPI... which is actually very little.
FastAPI is all based on these type hints, they give it many advantages and benefits.
But even if you never use FastAPI, you would benefit from learning a bit about them.
Note
If you are a Python expert, and you already know everything about type hints, skip to the next chapter.
Motivation¶
Let's start with a simple example:
def get_full_name(first_name, last_name):
full_name = first_name.title() + " " + last_name.title()
return full_name
print(get_full_name("john", "doe"))
Calling this program outputs:
John Doe
The function does the following:
- Takes a
first_name
andlast_name
. - Converts the first letter of each one to upper case with
title()
. - Concatenates them with a space in the middle.
def get_full_name(first_name, last_name):
full_name = first_name.title() + " " + last_name.title()
return full_name
print(get_full_name("john", "doe"))
Edit it¶
It's a very simple program.
But now imagine that you were writing it from scratch.
At some point you would have started the definition of the function, you had the parameters ready...
But then you have to call "that method that converts the first letter to upper case".
Was it upper
? Was it uppercase
? first_uppercase
? capitalize
?
Then, you try with the old programmer's friend, editor autocompletion.
You type the first parameter of the function, first_name
, then a dot (.
) and then hit Ctrl+Space
to trigger the completion.
But, sadly, you get nothing useful:
Add types¶
Let's modify a single line from the previous version.
We will change exactly this fragment, the parameters of the function, from:
first_name, last_name
to:
first_name: str, last_name: str
That's it.
Those are the "type hints":
def get_full_name(first_name: str, last_name: str):
full_name = first_name.title() + " " + last_name.title()
return full_name
print(get_full_name("john", "doe"))
That is not the same as declaring default values like would be with:
first_name="john", last_name="doe"
It's a different thing.
We are using colons (:
), not equals (=
).
And adding type hints normally doesn't change what happens from what would happen without them.
But now, imagine you are again in the middle of creating that function, but with type hints.
At the same point, you try to trigger the autocomplete with Ctrl+Space
and you see:
With that, you can scroll, seeing the options, until you find the one that "rings a bell":
More motivation¶
Check this function, it already has type hints:
def get_name_with_age(name: str, age: int):
name_with_age = name + " is this old: " + age
return name_with_age
Because the editor knows the types of the variables, you don't only get completion, you also get error checks:
Now you know that you have to fix it, convert age
to a string with str(age)
:
def get_name_with_age(name: str, age: int):
name_with_age = name + " is this old: " + str(age)
return name_with_age
Declaring types¶
You just saw the main place to declare type hints. As function parameters.
This is also the main place you would use them with FastAPI.
Simple types¶
You can declare all the standard Python types, not only str
.
You can use, for example:
int
float
bool
bytes
def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):
return item_a, item_b, item_c, item_d, item_d, item_e
Types with subtypes¶
There are some data structures that can contain other values, like dict
, list
, set
and tuple
. And the internal values can have their own type too.
To declare those types and the subtypes, you can use the standard Python module typing
.
It exists specifically to support these type hints.
Lists¶
For example, let's define a variable to be a list
of str
.
From typing
, import List
(with a capital L
):
from typing import List
def process_items(items: List[str]):
for item in items:
print(item)
Declare the variable, with the same colon (:
) syntax.
As the type, put the List
.
As the list is a type that takes a "subtype", you put the subtype in square brackets:
from typing import List
def process_items(items: List[str]):
for item in items:
print(item)
That means: "the variable items
is a list
, and each of the items in this list is a str
".
By doing that, your editor can provide support even while processing items from the list.
Without types, that's almost impossible to achieve:
Notice that the variable item
is one of the elements in the list items
.
And still, the editor knows it is a str
, and provides support for that.
Tuples and Sets¶
You would do the same to declare tuple
s and set
s:
from typing import Set, Tuple
def process_items(items_t: Tuple[int], items_s: Set[bytes]):
return items_t, items_s
This means:
- The variable
items_t
is atuple
, and each of its items is anint
. - The variable
items_s
is aset
, and each of its items is of typebytes
.
Dicts¶
To define a dict
, you pass 2 subtypes, separated by commas.
The first subtype is for the keys of the dict
.
The second subtype is for the values of the dict
:
from typing import Dict
def process_items(prices: Dict[str, float]):
for item_name, item_price in prices.items():
print(item_name)
print(item_price)
This means:
- The variable
prices
is adict
:- The keys of this
dict
are of typestr
(let's say, the name of each item). - The values of this
dict
are of typefloat
(let's say, the price of each item).
- The keys of this
Classes as types¶
You can also declare a class as the type of a variable.
Let's say you have a class Person
, with a name:
class Person:
def __init__(self, name: str):
self.name = name
def get_person_name(one_person: Person):
return one_person.name
Then you can declare a variable to be of type Person
:
class Person:
def __init__(self, name: str):
self.name = name
def get_person_name(one_person: Person):
return one_person.name
And then, again, you get all the editor support:
Pydantic models¶
Pydantic is a Python library to perform data validation.
You declare the "shape" of the data as classes with attributes.
And each attribute has a type.
Then you create an instance of that class with some values and it will validate the values, convert them to the appropriate type (if that's the case) and give you an object with all the data.
And you get all the editor support with that resulting object.
Taken from the official Pydantic docs:
from datetime import datetime
from typing import List
from pydantic import BaseModel
class User(BaseModel):
id: int
name = "John Doe"
signup_ts: datetime = None
friends: List[int] = []
external_data = {
"id": "123",
"signup_ts": "2017-06-01 12:22",
"friends": [1, "2", b"3"],
}
user = User(**external_data)
print(user)
# > User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
print(user.id)
# > 123
Info
To learn more about Pydantic, check its docs.
FastAPI is all based on Pydantic.
You will see a lot more of all this in practice in the Tutorial - User Guide.
Type hints in FastAPI¶
FastAPI takes advantage of these type hints to do several things.
With FastAPI you declare parameters with type hints and you get:
- Editor support.
- Type checks.
...and FastAPI uses the same declarations to:
- Define requirements: from request path parameters, query parameters, headers, bodies, dependencies, etc.
- Convert data: from the request to the required type.
- Validate data: coming from each request:
- Generating automatic errors returned to the client when the data is invalid.
- Document the API using OpenAPI:
- which is then used by the automatic interactive documentation user interfaces.
This might all sound abstract. Don't worry. You'll see all this in action in the Tutorial - User Guide.
The important thing is that by using standard Python types, in a single place (instead of adding more classes, decorators, etc), FastAPI will do a lot of the work for you.
Info
If you already went through all the tutorial and came back to see more about types, a good resource is the "cheat sheet" from mypy
.


Learning objectives
- Understand what makes a data set ‘tidy’ and why you’d want your data to be structured this way
- Use
pivot_longer()
andpivot_wider()
operations to restructure data frames- Tease apart columns containing multiple variables using
separate()
- Modify character variables using string manipulation functions from the stringr package
- Customize non-data components of plots created using ggplot2 by changing the theme
The data you collect or obtain from a third party is not always in a form that is suitable for exploratory analysis and visualization and may need to be restructured before you can fully make use of it.
This is particularly true of the plotting and summarizing tools we’ve been looking at in this course, which are designed specifically to work on data in a format referred to as ‘tidy’. This is where the tidyverse gets its name.
In this session, we will look at what it means for data to be ‘tidy’ and how you can transform your data, if necessary, into this form. We’ll also look at useful functions for handling compound variables, that is columns that contain more than one type of measurement or attribute (you’d be surprised how common this is) and some of the string manipulation functions from the stringr package that can help with cleaning up values within a data frame.
Finally, we’ll take another look at customizing plots created with ggplot2 by changing various non-data components that are largely cosmetic.
The functions we’re mostly focusing on in this session are from the tidyr and stringr packages both of which get loaded as part of the tidyverse.
library(tidyverse)
So what is ‘tidy data’ and why should we care about it?
To answer these questions, we’ll look at different ways in which a simple data set can be represented and consider the challenges associated with each. The data set in question is a subset of data from the World Health Organization Global Tuberculosis Report.
The tidyr package contains a series of tibbles that represent the same set of information on the number of new cases of tuberculosis (TB) recorded in each of 3 countries in the years 1999 and 2000 as well as the populations of those countries.
Here is the first table, table1
, that contains a row for every combination of country and year and separate columns containing the numbers of TB cases and the population.
table1
## # A tibble: 6 x 4
## country year cases population
## <chr> <int> <int> <int>
## 1 Afghanistan 1999<PHONE_NUMBER>1
## 2 Afghanistan 2000 2666 20595360
## 3 Brazil 1999 37737 172006362
## 4 Brazil 2000 80488 174504898
## 5 China 1999<PHONE_NUMBER>915272
## 6 China 2000<PHONE_NUMBER>428583
Two alternative ways of representing the same information are given in table2
and table3
. We’ll consider each of these in turn, shortly.
table2
## # A tibble: 12 x 4
## country year type count
## <chr> <int> <chr> <int>
## 1 Afghanistan 1999 cases 745
## 2 Afghanistan 1999 population 19987071
## 3 Afghanistan 2000 cases 2666
## 4 Afghanistan 2000 population 20595360
## 5 Brazil 1999 cases 37737
## 6 Brazil 1999 population 172006362
## 7 Brazil 2000 cases 80488
## 8 Brazil 2000 population 174504898
## 9 China 1999 cases 212258
## 10 China 1999 population<PHONE_NUMBER>
## 11 China 2000 cases 213766
## 12 China 2000 population<PHONE_NUMBER>
table3
## # A tibble: 6 x 3
## country year rate
## * <chr> <int> <chr>
## 1 Afghanistan 1999 745/19987071
## 2 Afghanistan 2000 2666/20595360
## 3 Brazil 1999 37737/172006362
## 4 Brazil 2000 80488/174504898
## 5 China 1999 212258/1272915272
## 6 China 2000 213766/1280428583
The final representation has the data split across two tables, a scenario that is actually quite likely given that population data will almost certainly have been collected separately from the recording of TB cases.
table4a
## # A tibble: 3 x 3
## country `1999` `2000`
## * <chr> <int> <int>
## 1 Afghanistan 745 2666
## 2 Brazil 37737 80488
## 3 China<PHONE_NUMBER>66
table4b
## # A tibble: 3 x 3
## country `1999` `2000`
## * <chr> <int> <int>
## 1 Afghanistan 19987071 20595360
## 2 Brazil 172006362 174504898
## 3 China<PHONE_NUMBER><PHONE_NUMBER>
Time series data like this are very commonly represented as they are in table4a
and table4b
with a series of dates or years as columns extending across a spreadsheet. You will find numerous examples of this if you seek out various data sets made available by the UK Office for National Statistics and various other national and international organizations.
Tables 1 to 4 are all different representations of the same underlying data but one of these tables is structured in such a way as to be most readily used in the tidyverse.
Tidy data
A tidy data set is a data frame (or table) for which the following are true:
A variable contains all values that measure the same underlying attribute (like height, temperature, duration) across units.
An observation contains all values measured on the same unit (like a person or a day) across attributes.
From ‘Tidy Data’ by Hadley Wickham.
Question: Which of the above representations of TB cases is tidy?
Another way of framing the question is to consider what are the variables in the TB data set, i.e. what are the things that vary and for which we can attach a value for each observation?
Take another look at tables 4a and 4b. Do each of the columns correspond to a variable? The country is certainly a variable. In this data set it takes one of three values: Afghanistan, Brazil or China.
But what about the other two columns, ‘1999’ and ‘2000’? These are values, not variables. The variable in this case would be ‘year’ and could take a value of 1999 or 2000. Tables 4a and 4b are not tidy.
There is also another rather obvious problem with tables 4a and 4b – the data are contained in two separate data frames. The data would almost certainly have been collected separately, so it’s hardly surprising, but whenever numbers of people affected by a disease, or engaging in an activity, are compared between countries we almost always want to be comparing the rate (the percentage within the population) and not the absolute number, so that the comparison is fair. We need to combine the data from these two tables in order to calculate the rate.
The only table that is truly tidy is table1
. It contains one column for each of the variables in the data set, namely country, year, the number of new TB cases and the population. We’ll look at tables 2 and 3 shortly and why these aren’t tidy and what we can do about it, but first we’ll see how we can convert tables 4a and 4b into the tidy format.
pivot_longer()
Tables 4a and 4b are examples of what is often referred to as ‘wide format’. While neither table looks especially wide, you can imagine that the more complete WHO data set contains data for very many years and that if each had its own column, the table would be very much wider.
What we need is a column for ‘year’ so that we have a count, whether it is the number of TB cases or the population, for each unique combination of country and year. Transforming the table in this way is known as ‘pivoting’ and the tidyr package provides the pivot_longer()
function for just such an operation.
table4a
## # A tibble: 3 x 3
## country `1999` `2000`
## * <chr> <int> <int>
## 1 Afghanistan 745 2666
## 2 Brazil 37737 80488
## 3 China<PHONE_NUMBER>66
table4a_long <- pivot_longer(table4a, c(`1999`, `2000`), names_to = "year", values_to = "cases")
table4a_long
## # A tibble: 6 x 3
## country year cases
## <chr> <chr> <int>
## 1 Afghanistan 1999 745
## 2 Afghanistan 2000 2666
## 3 Brazil 1999 37737
## 4 Brazil 2000 80488
## 5 China 1999 212258
## 6 China 2000 213766
As with almost all tidyverse operations the first argument is the data frame we’re working on. The second specifies which columns we are operating on. Here we’ve used a vector with c()
but it is also quite customary and normally more convenient to use a range of columns, e.g. `1999`:`2000`
. Remember that we have to use backticks because R doesn’t like variable names starting with numbers.
Pivoting operations
pivot_longer(data, cols, names_to = “name”, values_to = “value”)
Pivot data from wide to long, increasing the number of rows and decreasing the number of columns.
table4a_long <- pivot_longer(table4a, c(“1999”, “2000”), names_to = “year”, values_to = “cases”)
pivot_wider(data, names_from = name, values_from = value)
Pivot data from long to wide, increasing the number of columns and decreasing the number of rows.
table4a_wide <- pivot_wider(table4a_long, names_from = year, values_from = cases)
The names_to
and values_to
arguments are so called because we are taking the names of the columns we specified (1999 and 2000) and putting these in a new column with a name given by names_to
. Likewise, we are taking values in each of our specified columns and putting these in a new column whose name is given by values_to
.
We can do the same with table4b
and join the two resulting tables together to recreate table1
.
table4b_long <- pivot_longer(table4b, c(`1999`, `2000`), names_to = "year", values_to = "population")
table4b_long
## # A tibble: 6 x 3
## country year population
## <chr> <chr> <int>
## 1 Afghanistan 1999 19987071
## 2 Afghanistan 2000 20595360
## 3 Brazil 1999 172006362
## 4 Brazil 2000 174504898
## 5 China 1999<PHONE_NUMBER>
## 6 China 2000<PHONE_NUMBER>
# join the two pivoted tables to recreate table1
left_join(table4a_long, table4b_long, by = c("country", "year"))
## # A tibble: 6 x 4
## country year cases population
## <chr> <chr> <int> <int>
## 1 Afghanistan 1999<PHONE_NUMBER>1
## 2 Afghanistan 2000 2666 20595360
## 3 Brazil 1999 37737 172006362
## 4 Brazil 2000 80488 174504898
## 5 China 1999<PHONE_NUMBER>915272
## 6 China 2000<PHONE_NUMBER>428583
pivot_wider()
pivot_wider()
has the opposite effect of pivot_longer()
and can be used to reverse the pivoting operation we just performed on table4a
.
table4a_long
## # A tibble: 6 x 3
## country year cases
## <chr> <chr> <int>
## 1 Afghanistan 1999 745
## 2 Afghanistan 2000 2666
## 3 Brazil 1999 37737
## 4 Brazil 2000 80488
## 5 China 1999 212258
## 6 China 2000 213766
pivot_wider(table4a_long, names_from = "year", values_from = "cases")
## # A tibble: 3 x 3
## country `1999` `2000`
## <chr> <int> <int>
## 1 Afghanistan 745 2666
## 2 Brazil 37737 80488
## 3 China<PHONE_NUMBER>66
pivot_wider()
has looked for all distinct values in the year
column and created a new column for each. The values are taken from the cases
column. An NA
would be inserted into the new columns for any instances where there is no observation for a given year. That isn’t the case in this example but we can show this by removing the last row from table4a_long
.
table4a_long <- head(table4a_long, 5)
table4a_long
## # A tibble: 5 x 3
## country year cases
## <chr> <chr> <int>
## 1 Afghanistan 1999 745
## 2 Afghanistan 2000 2666
## 3 Brazil 1999 37737
## 4 Brazil 2000 80488
## 5 China 1999 212258
pivot_wider(table4a_long, names_from = "year", values_from = "cases")
## # A tibble: 3 x 3
## country `1999` `2000`
## <chr> <int> <int>
## 1 Afghanistan 745 2666
## 2 Brazil 37737 80488
## 3 China 212258 NA
In some cases the wide format is the more human-readable form and usually it is a more compact way of representing the data. In this example, there is no duplication of the year value in the wide format of table4a
and table4b
. We will see later that this is much more apparent with larger data tables, e.g. gene expression matrices.
Let’s look again at table2
.
table2
## # A tibble: 12 x 4
## country year type count
## <chr> <int> <chr> <int>
## 1 Afghanistan 1999 cases 745
## 2 Afghanistan 1999 population 19987071
## 3 Afghanistan 2000 cases 2666
## 4 Afghanistan 2000 population 20595360
## 5 Brazil 1999 cases 37737
## 6 Brazil 1999 population 172006362
## 7 Brazil 2000 cases 80488
## 8 Brazil 2000 population 174504898
## 9 China 1999 cases 212258
## 10 China 1999 population<PHONE_NUMBER>
## 11 China 2000 cases 213766
## 12 China 2000 population<PHONE_NUMBER>
Are the type and count columns true variables? And what is the observational unit in this case?
If we consider the observational unit to be a country in a specific year then table2
is not tidy because observations are split across two rows. Also the count variable contains counts of what are essentially different things, the number of cases of TB or the total population.
In tricky situations like this, a tell-tale sign that the data is not in a tidy format is when we attempt to perform some exploratory data analysis and visualization and find we’re having to do quite a bit of work to calculate or plot what we want.
For example, if we wanted to create a bar plot of the numbers of TB cases in each country, we would have to first remove the rows corresponding to the populations using a filter operation. Surely that wouldn’t be necessary if the data were tidy.
Similarly, the rate of new TB cases, i.e. the proportion of the population infected with TB, is something we should be able to calculate easily in a simple operation. However, this is actually quite difficult to do with the data structured as they are in table2
.
We can use pivot_wider()
to sort this out. The type
column contains the variable names so we’d need to set names_from = "type"
, while the values will be taken from the count
column.
table2_fixed <- pivot_wider(table2, names_from = "type", values_from = "count")
table2_fixed
## # A tibble: 6 x 4
## country year cases population
## <chr> <int> <int> <int>
## 1 Afghanistan 1999<PHONE_NUMBER>1
## 2 Afghanistan 2000 2666 20595360
## 3 Brazil 1999 37737 172006362
## 4 Brazil 2000 80488 174504898
## 5 China 1999<PHONE_NUMBER>915272
## 6 China 2000<PHONE_NUMBER>428583
The resulting table is exactly the same as table1
and now the rate of infection can be calculated rather straightforwardly.
mutate(table2_fixed, rate = cases / population)
## # A tibble: 6 x 5
## country year cases population rate
## <chr> <int> <int> <int> <dbl>
## 1 Afghanistan 1999<PHONE_NUMBER>1 0.0000373
## 2 Afghanistan 2000 2666 20595360 0.000129
## 3 Brazil 1999 37737 172006362 0.000219
## 4 Brazil 2000 80488 174504898 0.000461
## 5 China 1999<PHONE_NUMBER>915272 0.000167
## 6 China 2000<PHONE_NUMBER>428583 0.000167
Table 3 contains an example of a column that contains multiple values. It is a somewhat convoluted example but occasionally you may come across data like this.
table3
## # A tibble: 6 x 3
## country year rate
## * <chr> <int> <chr>
## 1 Afghanistan 1999 745/19987071
## 2 Afghanistan 2000 2666/20595360
## 3 Brazil 1999 37737/172006362
## 4 Brazil 2000 80488/174504898
## 5 China 1999 212258/1272915272
## 6 China 2000 213766/1280428583
The rate
column contains both the number of TB cases and the population separated by a ‘/’ character. The rate column is a character type so not terribly useful for doing anything of a mathematical nature in its current guise.
separate()
The separate()
function allows us to split a character column into multiple columns based on a delimiter or separator.
table3_separated <- separate(table3, rate, into = c("cases", "population"), sep = "/")
table3_separated
## # A tibble: 6 x 4
## country year cases population
## <chr> <int> <chr> <chr>
## 1 Afghanistan 1999<PHONE_NUMBER>1
## 2 Afghanistan 2000 2666 20595360
## 3 Brazil 1999 37737 172006362
## 4 Brazil 2000 80488 174504898
## 5 China 1999<PHONE_NUMBER>915272
## 6 China 2000<PHONE_NUMBER>428583
The sep
argument takes a regular expression that defines how to split the values. We’ve mentioned regular expressions before – they are a language for specifying search patterns used to find sequences of characters within text and well worth learning. In this case our separator is just the ‘/’ character.
The resulting data frame is still not quite what we want though. This becomes apparent as soon as we try to do anything with the new cases
and population
columns.
mutate(table3_separated, rate = cases / population)
## Error: Problem with `mutate()` input `rate`.
## ✖ non-numeric argument to binary operator
## ℹ Input `rate` is `cases/population`.
By default the separated values are character types. We could convert these using mutate_at()
.
mutate_at(table3_separated, vars(cases, population), as.integer)
## # A tibble: 6 x 4
## country year cases population
## <chr> <int> <int> <int>
## 1 Afghanistan 1999<PHONE_NUMBER>1
## 2 Afghanistan 2000 2666 20595360
## 3 Brazil 1999 37737 172006362
## 4 Brazil 2000 80488 174504898
## 5 China 1999<PHONE_NUMBER>915272
## 6 China 2000<PHONE_NUMBER>428583
But another option is to specify convert = TRUE
when carrying out the separate()
operation, in which case it will deduce the type of the values and convert the column accordingly.
table3_separated <- separate(table3, rate, into = c("cases", "population"), sep = "/", convert = TRUE)
mutate(table3_separated, rate = cases / population)
## # A tibble: 6 x 5
## country year cases population rate
## <chr> <int> <int> <int> <dbl>
## 1 Afghanistan 1999<PHONE_NUMBER>1 0.0000373
## 2 Afghanistan 2000 2666 20595360 0.000129
## 3 Brazil 1999 37737 172006362 0.000219
## 4 Brazil 2000 80488 174504898 0.000461
## 5 China 1999<PHONE_NUMBER>915272 0.000167
## 6 China 2000<PHONE_NUMBER>428583 0.000167
Although tables 1 to 4 contain real data they are, of course, ‘toy’ data frames created for demonstration and teaching purposes. We’ll now turn our attention to the METABRIC expression data and see how this needs to be transformed into a tidier format to open up different avenues for exploring the data.
We’ll first load the table and then select just the columns we’re going to need.
metabric <- read_csv("data/metabric_clinical_and_expression_data.csv") %>%
select(Patient_ID, ER_status, ESR1:MLPH)
metabric
## # A tibble: 1,904 x 10
## Patient_ID ER_status ESR1 ERBB2 PGR TP53 PIK3CA GATA3 FOXA1 MLPH
## <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 MB-0000 Positive 8.93 9.33 5.68 6.34 5.70 6.93 7.95 9.73
## 2 MB-0002 Positive 10.0 9.73 7.51 6.19 5.76 11.3 11.8 12.5
## 3 MB-0005 Positive 10.0 9.73 7.38 6.40 6.75 9.29 11.7 10.3
## 4 MB-0006 Positive 10.4 10.3 6.82 6.87 7.22 8.67 11.9 10.5
## 5 MB-0008 Positive 11.3 9.96 7.33 6.34 5.82 9.72 11.6 12.2
## 6 MB-0010 Positive 11.2 9.74 5.95 5.42 6.12 9.79 12.1 11.4
## 7 MB-0014 Positive 10.8 9.28 7.72 5.99 7.48 8.37 11.5 10.8
## 8 MB-0022 Positive 10.4 8.61 5.59 6.17 7.59 7.87 10.7 9.95
## 9 MB-0028 Positive 12.5 10.7 5.33 6.22 6.25 10.3 12.1 10.9
## 10 MB-0035 Positive 7.54 11.5 5.59 6.41 5.99 10.2 12.8 13.5
## # … with 1,894 more rows
When we first looked at visualization using ggplot2 we created the following box plot.
ggplot(metabric) +
geom_boxplot(mapping = aes(x = ER_status, y = GATA3))
But what if we would like to create a series of plots using the faceting functions in ggplot2 with one plot for each gene?
Faceting requires a categorical variable, which is used to divide the data into subsets to be used for each plot. In this case we’d need a gene column. Clearly our data are not structured in this way.
We have gene names for column headings. Are these variables? Well, maybe, although a more correct name for each of these variables or column headings would be ‘Expression of ESR1’, ‘Expression of ERBB2’, etc.
But we could consider that these gene column headings are actually values of a variable called ‘gene’ or ‘gene symbol’. In this regard, what we have is a ‘wide format’ table.
Most gene expression matrices have a similar form, although usually there have rows for each gene and columns for each sample. It should be said that the gene expression matrix format is a very compact way of representing the data which could be a consideration when dealing with tens of thousands of genes and anywhere between a few tens of samples to a few thousand, such is the case for METABRIC.
Furthermore, there are lots of tools for working with gene expression data in the form of matrices, including many packages in the Bioconductor project. Fortunately, as we’ve seen, pivot_longer()
and pivot_wider()
provide a very convenient means of converting between tidy and matrix-like formats.
We’ll convert our table of ER status and gene expression data to the tidy format.
metabric <- pivot_longer(metabric, ESR1:MLPH, names_to = "Gene", values_to = "Expression")
metabric
## # A tibble: 15,232 x 4
## Patient_ID ER_status Gene Expression
## <chr> <chr> <chr> <dbl>
## 1 MB-0000 Positive ESR1 8.93
## 2 MB-0000 Positive ERBB2 9.33
## 3 MB-0000 Positive PGR 5.68
## 4 MB-0000 Positive TP53 6.34
## 5 MB-0000 Positive PIK3CA 5.70
## 6 MB-0000 Positive GATA3 6.93
## 7 MB-0000 Positive FOXA1 7.95
## 8 MB-0000 Positive MLPH 9.73
## 9 MB-0002 Positive ESR1 10.0
## 10 MB-0002 Positive ERBB2 9.73
## # … with 15,222 more rows
Note how we specified a range of columns between ESR1
and MLPH
, which is a lot easier than naming each column individually.
We’re now in a position to create our faceted box plot chart.
ggplot(data = metabric) +
geom_boxplot(mapping = aes(x = ER_status, y = Expression)) +
facet_wrap(vars(Gene))
In carrying out this transformation, the observational unit has changed. The tidy format has one-row-per-gene-per-sample, while wide format was one-row-per-sample. The tidy format is much less compact and involves considerable duplication of values in the first three columns (Patient_ID
, ER_status
and Gene
).
One of the other plot types we’ve used in exploring these data was a scatter plot comparing the expression of two genes across all the samples. For this, the one-row-per-sample representation is the more appropriate and being able to convert back to this format allows us to create the plot.
metabric %>%
pivot_wider(names_from = "Gene", values_from = "Expression") %>%
ggplot() +
geom_point(mapping = aes(x = GATA3, y = ESR1, colour = ER_status))
Our second real example features another data set generated by CRUK CI scientists (Papachristou et al., Nature Communications 9:2311, 2018) in which the dynamics of endogenous chromatin-associated protein complexes were investigated using quantitative mass spectrometry.
We’ll look at just one of several tabular data sets made available as supplementary data, which contains the total level of protein in MCF-7 cells at various time points after treatment with the drug tamoxifen. MCF-7 is a breast cancer cell line isolated in 1970 from a 69-year old woman and established for use in breast cancer research by the Michigan Cancer Foundation-7 institute in Detroit. Tamoxifen is a hormone therapy used in the treatment of estrogen receptor-positive breast cancer.
The table in question is supplementary data 9.
library(readxl)
protein_levels <- read_excel("data/41467_2018_4619_MOESM11_ESM.xlsx", skip = 1)
select(protein_levels, `Uniprot Accession`, `Gene Name`, ends_with("rep01"))
## # A tibble: 7,943 x 6
## `Uniprot Access… `Gene Name` vehicle.rep01 tam.2h.rep01 tam.6h.rep01
## <chr> <chr> <dbl> <dbl> <dbl>
## 1 Q09666 AHNAK 17.3 17.3 17.3
## 2 P05787 KRT8 16.9 17.1 17.0
## 3 Q15149 PLEC 16.7 16.7 16.7
## 4 P21333 FLNA 16.6 16.5 16.6
## 5 P05783 KRT18 16.4 16.6 16.5
## 6 P49327 FASN 16.0 16.0 16.0
## 7 P10809 HSPD1 16.1 16.2 16.1
## 8 Q14204 DYNC1H1 16.0 15.9 16.0
## 9 O75369 FLNB 16.1 16.1 16.2
## 10 P35579 MYH9 15.7 15.6 15.8
## # … with 7,933 more rows, and 1 more variable: tam.24h.rep01 <dbl>
This has a very similar structure to a gene expression matrix having one row for each protein (or gene) and a column for each sample. We’ve only shown columns for the first of four replicates for each group defined by a treatment and a time point. The control group is, in effect, the ‘untreated’ group in which the cells are treated with the vehicle (ethanol) alone.
If we wanted to calculate the mean protein levels within each group, i.e. the average level for the protein measured in the 4 replicates, or we wanted to show the spread of values for the replicates as a box plot, then the data as currently structured is not in the most suitable form. In what follows, we’ll transform the table to allow us to do both these analyses.
To simplify matters, we’re going to focus on just a few proteins, those whose levels are markedly reduced 24 hours after treatment with tamoxifen compared with the vehicle.
protein_levels <- protein_levels %>%
filter(`log2FC(24h/veh)` < -0.75) %>%
select(accession = `Uniprot Accession`, gene = `Gene Name`, vehicle.rep01:tam.24h.rep04)
protein_levels
## # A tibble: 10 x 18
## accession gene vehicle.rep01 tam.2h.rep01 tam.6h.rep01 tam.24h.rep01
## <chr> <chr> <dbl> <dbl> <dbl> <dbl>
## 1 Q4ZG55 GREB1 12.1 12 11.6 9.78
## 2 P15514 AREG 11.4 11.3 11.3 9.92
## 3 Q13433 SLC3… 10.9 10.8 10.7 9.89
## 4 Q9NPD8 UBE2T 10.4 10.3 10.2 9.62
## 5 Q6N021 TET2 10.1 10.0 9.59 8.75
## 6 P06401 PGR 9.97 10.0 9.75 8.75
## 7 P25929 NPY1R 9.08 9.16 8.89 7.94
## 8 O95084 PRSS… 8.45 8.53 8.27 7.78
## 9 P08493 MGP 6.76 6.76 6.18 5.09
## 10 Q96BR1 SGK3 6.33 6.42 6.16 5.5
## # … with 12 more variables: vehicle.rep02 <dbl>, tam.2h.rep02 <dbl>,
## # tam.6h.rep02 <dbl>, tam.24h.rep02 <dbl>, vehicle.rep03 <dbl>,
## # tam.2h.rep03 <dbl>, tam.6h.rep03 <dbl>, tam.24h.rep03 <dbl>,
## # vehicle.rep04 <dbl>, tam.2h.rep04 <dbl>, tam.6h.rep04 <dbl>,
## # tam.24h.rep04 <dbl>
This is a fairly typical example of a table with columns for each sample where the sample names contain quite a lot of information, in this case:
To make use of this information we need to pivot the table such that the sample name is in a column and protein levels are in another column, and then to split the sample name column into its constituent parts.
For the first part of this transformation we’ll use pivot_longer()
.
protein_levels <- pivot_longer(protein_levels, vehicle.rep01:tam.24h.rep04, names_to = "sample", values_to = "protein_level")
protein_levels
## # A tibble: 160 x 4
## accession gene sample protein_level
## <chr> <chr> <chr> <dbl>
## 1 Q4ZG55 GREB1 vehicle.rep01 12.1
## 2 Q4ZG55 GREB1 tam.2h.rep01 12
## 3 Q4ZG55 GREB1 tam.6h.rep01 11.6
## 4 Q4ZG55 GREB1 tam.24h.rep01 9.78
## 5 Q4ZG55 GREB1 vehicle.rep02 11.3
## 6 Q4ZG55 GREB1 tam.2h.rep02 11.4
## 7 Q4ZG55 GREB1 tam.6h.rep02 11.1
## 8 Q4ZG55 GREB1 tam.24h.rep02 8.98
## 9 Q4ZG55 GREB1 vehicle.rep03 11.0
## 10 Q4ZG55 GREB1 tam.2h.rep03 11.0
## # … with 150 more rows
Now we can use separate()
to disentangle the components of the sample name.
It looks like we need to split on the ‘.’ character but that has a special meaning in a regular expression, i.e. match any character. Fortunately, the default regular expression used by separate()
splits on any character that isn’t a letter or a number, so will do just fine.
But there is another problem. The vehicle sample names don’t follow the pattern of “treatment.time.replicate”. In actual fact the vehicle measurements were taken 24 hours after treatment with ethanol alone. What we should do to correct matters is add the ‘24h’ component. For that, we’re going to use one of several really useful string manipulation functions provided by the stringr package.
Some useful stringr functions
str_c(…, sep = “”)
Join multiple strings into a single string.
str_c(“tidyverse”, “fab”, sep = " is “)
[1] “tidyverse is fab”
str_c(c(“Ashley”, “Matt”), c(“hiking”, “beer”), sep = " loves “)
[1] “Ashley loves hiking” “Matt loves beer”
str_replace(string, pattern, replacement)
str_replace_all(string, pattern, replacement)
Substitute a matched pattern in a string (or character vector).
str_replace(“Oscar is the best cat in the world”, “best”, “loveliest”)
[1] “Oscar is the loveliest cat in the world”
str_replace_all(“the cat sat on the mat”, “at”, “AT”)
[1] “the cAT sAT on the mAT”
str_remove(string, pattern)
str_remove_all(string, pattern)
Remove matched patterns in a string.
Alias for str_replace(string, pattern, “”)
and str_replace_all(string, pattern, “”)
.
str_sub(string, start, end)
Extract substrings from a character vector at the given start and end positions.
str_sub(“Matthew”, start = 1, end = 4)
[1] “Matt”
str_sub(c(“tamoxifen”, “vehicle”), 1, 3)
[1] “tam” “veh”
str_replace()
looks like the function we need so let’s see how it works on our sample names.
str_replace("vehicle.rep01", "vehicle", "vehicle.24h")
## [1] "vehicle.24h.rep01"
The first argument is the character vector we’re working on, in this case a single character string. The second argument is the pattern or substring we want to replace and the third is the string we want to replace it with.
Looking at the help we can see that, like very many R functions, it works on a vector of character values (or strings), so let’s try this on a few of our sample names, say the first 10.
str_replace(protein_levels$sample[1:10], "vehicle", "vehicle.24h")
## [1] "vehicle.24h.rep01" "tam.2h.rep01" "tam.6h.rep01"
## [4] "tam.24h.rep01" "vehicle.24h.rep02" "tam.2h.rep02"
## [7] "tam.6h.rep02" "tam.24h.rep02" "vehicle.24h.rep03"
## [10] "tam.2h.rep03"
Finally, we can modify the values in our data frame using mutate()
.
protein_levels <- mutate(protein_levels, sample = str_replace(sample, "vehicle", "vehicle.24h"))
protein_levels
## # A tibble: 160 x 4
## accession gene sample protein_level
## <chr> <chr> <chr> <dbl>
## 1 Q4ZG55 GREB1 vehicle.24h.rep01 12.1
## 2 Q4ZG55 GREB1 tam.2h.rep01 12
## 3 Q4ZG55 GREB1 tam.6h.rep01 11.6
## 4 Q4ZG55 GREB1 tam.24h.rep01 9.78
## 5 Q4ZG55 GREB1 vehicle.24h.rep02 11.3
## 6 Q4ZG55 GREB1 tam.2h.rep02 11.4
## 7 Q4ZG55 GREB1 tam.6h.rep02 11.1
## 8 Q4ZG55 GREB1 tam.24h.rep02 8.98
## 9 Q4ZG55 GREB1 vehicle.24h.rep03 11.0
## 10 Q4ZG55 GREB1 tam.2h.rep03 11.0
## # … with 150 more rows
Now we’re ready to separate the sample
column into its component parts.
protein_levels <- separate(protein_levels, sample, into = c("treatment", "time", "replicate"))
protein_levels
## # A tibble: 160 x 6
## accession gene treatment time replicate protein_level
## <chr> <chr> <chr> <chr> <chr> <dbl>
## 1 Q4ZG55 GREB1 vehicle 24h rep01 12.1
## 2 Q4ZG55 GREB1 tam 2h rep01 12
## 3 Q4ZG55 GREB1 tam 6h rep01 11.6
## 4 Q4ZG55 GREB1 tam 24h rep01 9.78
## 5 Q4ZG55 GREB1 vehicle 24h rep02 11.3
## 6 Q4ZG55 GREB1 tam 2h rep02 11.4
## 7 Q4ZG55 GREB1 tam 6h rep02 11.1
## 8 Q4ZG55 GREB1 tam 24h rep02 8.98
## 9 Q4ZG55 GREB1 vehicle 24h rep03 11.0
## 10 Q4ZG55 GREB1 tam 2h rep03 11.0
## # … with 150 more rows
The groups we want to compare are in fact the combination of the treatment and the time point. We’ll create a new column called ‘group’ in which we concatenate the treatment and time values using another stringr function, str_c()
. But we’ll also shorten ‘vehicle’ to ‘veh’ so we have similar length treatment labels (‘veh’ and ‘tam’) in the plot we’ll eventually create. For that we’ll use str_sub()
. Our group variable is categorical so we’ll convert this to a factor while we’re at it.
protein_levels <- protein_levels %>%
mutate(group = str_sub(treatment, 1, 3)) %>%
mutate(group = str_c(group, time)) %>%
mutate(group = as_factor(group))
protein_levels
## # A tibble: 160 x 7
## accession gene treatment time replicate protein_level group
## <chr> <chr> <chr> <chr> <chr> <dbl> <fct>
## 1 Q4ZG55 GREB1 vehicle 24h rep01 12.1 veh24h
## 2 Q4ZG55 GREB1 tam 2h rep01 12 tam2h
## 3 Q4ZG55 GREB1 tam 6h rep01 11.6 tam6h
## 4 Q4ZG55 GREB1 tam 24h rep01 9.78 tam24h
## 5 Q4ZG55 GREB1 vehicle 24h rep02 11.3 veh24h
## 6 Q4ZG55 GREB1 tam 2h rep02 11.4 tam2h
## 7 Q4ZG55 GREB1 tam 6h rep02 11.1 tam6h
## 8 Q4ZG55 GREB1 tam 24h rep02 8.98 tam24h
## 9 Q4ZG55 GREB1 vehicle 24h rep03 11.0 veh24h
## 10 Q4ZG55 GREB1 tam 2h rep03 11.0 tam2h
## # … with 150 more rows
Computing the mean protein levels within each group is now very straightforward.
protein_levels %>%
group_by(accession, gene, group) %>%
summarize(protein_level = mean(protein_level))
## `summarise()` regrouping output by 'accession', 'gene' (override with `.groups` argument)
## # A tibble: 40 x 4
## # Groups: accession, gene [10]
## accession gene group protein_level
## <chr> <chr> <fct> <dbl>
## 1 O95084 PRSS23 veh24h 8.16
## 2 O95084 PRSS23 tam2h 8.2
## 3 O95084 PRSS23 tam6h 8.03
## 4 O95084 PRSS23 tam24h 7.20
## 5 P06401 PGR veh24h 9.44
## 6 P06401 PGR tam2h 9.66
## 7 P06401 PGR tam6h 9.41
## 8 P06401 PGR tam24h 8.39
## 9 P08493 MGP veh24h 5.59
## 10 P08493 MGP tam2h 5.69
## # … with 30 more rows
Plotting the protein levels in each group as box plots with each data point overlaid is only slightly more involved. We can use faceting to create separate plots for each of the proteins (we’ll use gene symbols as they’re more recognizable).
ggplot(data = protein_levels, mapping = aes(x = group, y = protein_level)) +
geom_boxplot(colour = "grey60") +
geom_jitter(width = 0.15) +
facet_wrap(vars(gene), scales = "free_y", ncol = 3)
Finally, we’ll turn our attention back to visualization using ggplot2 and how we can customize our plots by changing the theme and consider various other odds and ends.
Themes can be used to customize non-data components of a plot. Let’s create a plot showing the expression of estrogen receptor alpha (ESR1) for each of the Integrative cluster breast cancer subtypes.
# read in the METABRIC data, convert the Integrative_cluster variable into a
# categorical variable with the levels in the correct order, and select just
# the columns and rows we're going to use
metabric <- read_csv("data/metabric_clinical_and_expression_data.csv") %>%
mutate(Integrative_cluster = factor(Integrative_cluster, levels = c("1", "2", "3", "4ER-", "4ER+", "5", "6", "7", "8", "9", "10"))) %>%
mutate(`3-gene_classifier` = replace_na(`3-gene_classifier`, "Unclassified")) %>%
select(Patient_ID, ER_status, PR_status, `3-gene_classifier`, Integrative_cluster, ESR1) %>%
filter(!is.na(Integrative_cluster), !is.na(ESR1))
metabric
## # A tibble: 1,904 x 6
## Patient_ID ER_status PR_status `3-gene_classifie… Integrative_clu… ESR1
## <chr> <chr> <chr> <chr> <fct> <dbl>
## 1 MB-0000 Positive Negative ER-/HER2- 4ER+ 8.93
## 2 MB-0002 Positive Positive ER+/HER2- High Pr… 4ER+ 10.0
## 3 MB-0005 Positive Positive Unclassified 3 10.0
## 4 MB-0006 Positive Positive Unclassified 9 10.4
## 5 MB-0008 Positive Positive ER+/HER2- High Pr… 9 11.3
## 6 MB-0010 Positive Positive ER+/HER2- High Pr… 7 11.2
## 7 MB-0014 Positive Positive Unclassified 3 10.8
## 8 MB-0022 Positive Negative Unclassified 3 10.4
## 9 MB-0028 Positive Negative ER+/HER2- High Pr… 9 12.5
## 10 MB-0035 Positive Negative ER+/HER2- High Pr… 3 7.54
## # … with 1,894 more rows
# plot the ESR1 expression for each integrative cluster
plot <- ggplot(data = metabric) +
geom_boxplot(mapping = aes(x = Integrative_cluster, y = ESR1, fill = Integrative_cluster)) +
labs(x = "Integrative cluster", y = "ESR1 expression")
plot
The default theme has the characteristic grey background which isn’t particularly suitable for printing on paper. We can change to one of a number of alternative themes available in the ggplot2 package, e.g. the black and white theme.
plot + theme_bw()
The help page for the available themes, which can be accessed using ?theme_bw
, lists each and when you might want to use them. It states that black_bw
may work better for presentations displayed on a projector.
Each of these themes is really just a collection of attributes relating to how various non-data elements of the plot will be displayed. We can override any of these individual settings using the theme()
function. A look at the help page (?theme
) shows that there are a very large number of settings that you can change. The following example demonstrates a few of these.
plot +
theme_bw() +
theme(
panel.grid.major.x = element_blank(),
axis.ticks.x = element_blank(),
legend.position = "none"
)
Here’s another example that also involves customizing the labels, scales and colours.
ggplot(data = metabric) +
geom_bar(mapping = aes(x = `3-gene_classifier`, fill = ER_status)) +
scale_y_continuous(limits = c(0, 700), breaks = seq(0, 700, 100), expand = expand_scale(mult = 0)) +
scale_fill_manual(values = c("firebrick2", "dodgerblue2")) +
labs(x = NULL, y = "samples", fill = "ER status") +
theme_bw() +
theme(
panel.border = element_blank(),
panel.grid = element_blank(),
axis.ticks.x = element_blank(),
axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1),
axis.line.y = element_line(),
axis.ticks.length.y = unit(0.2, "cm"),
legend.position = "bottom"
)
The ggthemes package contains some extra themes and might be fun to check out. Here’s an example of a plot that uses the theme_gdocs
theme that resembles the default look of charts in Google Docs.
library(ggthemes)
metabric %>%
filter(`3-gene_classifier` == "HER2+") %>%
ggplot(mapping = aes(x = PR_status, y = ESR1)) +
geom_boxplot() +
geom_jitter(mapping = aes(colour = PR_status), width = 0.25, alpha = 0.4, show.legend = FALSE) +
scale_colour_brewer(palette = "Set1") +
labs(x = "PR status", y = "ESR1 expression") +
theme_gdocs()
All geoms in ggplot2 have a position adjustment that can be set using the position
argument. This has different effects for different types of plot but essentially this resolves how overlapping geoms are displayed.
For example, let’s consider the stacked bar plot we created earlier showing the numbers of patients in each of the 3-gene classifications subdivided by ER status. The default position value for geom_bar()
is “stack” which is why the plot is shown as a stacked bar chart. An alternative way of representing these data would be to show separate bars for each ER status side-by-side by setting position = "dodge"
.
ggplot(data = metabric) +
geom_bar(mapping = aes(x = `3-gene_classifier`, fill = ER_status), position = "dodge") +
scale_y_continuous(limits = c(0, 700), breaks = seq(0, 700, 100), expand = expand_scale(mult = 0)) +
scale_fill_manual(values = c("firebrick2", "dodgerblue2")) +
labs(x = NULL, y = "samples", fill = "ER status") +
theme_bw() +
theme(
panel.border = element_blank(),
panel.grid = element_blank(),
axis.ticks.x = element_blank(),
axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1),
axis.line.y = element_line(),
axis.ticks.length.y = unit(0.2, "cm")
)
Another position adjustment we’ve come across is geom_jitter()
, which is just a convenient shortcut for geom_point(position = "jitter")
. A variation on this, position_jitterdodge()
, comes in handy when we are overlaying points on top of a box plot. We show an example of just such a plot in which first use postion = "jitter"
.
metabric %>%
ggplot(mapping = aes(x = `3-gene_classifier`, y = ESR1, colour = PR_status)) +
geom_boxplot() +
geom_point(position = "jitter", size = 0.5, alpha = 0.3) +
labs(x = "3-gene classification", y = "ESR1 expression", colour = "PR status") +
scale_color_brewer(palette = "Set1") +
theme_minimal() +
theme(
panel.grid.major.x = element_blank(),
axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1),
axis.ticks.x = element_blank()
)
The PR-negative and PR-positive points have distinct colours but are overlapping in a way that is aesthetically displeasing. What we want is for the points to have both jitter and to be dodged in the same way as the boxes. With position_jitterdodge()
we get a better looking plot.
metabric %>%
ggplot(mapping = aes(x = `3-gene_classifier`, y = ESR1, colour = PR_status)) +
geom_boxplot() +
geom_point(position = position_jitterdodge(), size = 0.5, alpha = 0.3) +
labs(x = "3-gene classification", y = "ESR1 expression", colour = "PR status") +
scale_color_brewer(palette = "Set1") +
theme_minimal() +
theme(
panel.grid.major.x = element_blank(),
axis.text.x = element_text(angle = 45, hjust = 1, vjust = 1),
axis.ticks.x = element_blank()
)
Use ggsave()
to save the last plot you displayed.
ggsave("esr1_expression.png")
You can alter the width and height of the plot and can change the image file type.
ggsave("esr1_expression.pdf", width = 20, height = 12, units = "cm")
You can also pass in a plot object you have created instead of using the last plot displayed. See the help page (?ggsave
) for more details.
In this session we have covered the following:
Assignment: assignment6.Rmd
Solutions: assignment6_solutions.Rmd and assignment6_solutions.html


For those of you coming into town early, we are planning a casual pool party / barbecue for Saturday, September 7, if the weather is good.
Where: Staybridge Suites Wilmington - Brandywine Valley.
When: Join us anytime between 12:00pm and 8:00pm.
We will provide food and drink.
Aside from the barbecue, you may wish to explore Philadelphia and the surrounding areas. Philadelphia is a city rich with American history. Here are some ideas for things to do while you are in town (in addition to finding a good Philly cheese steak).
History
Some of the highlights are the Liberty Bell and Independence Hall, but we suggest following the tour on the official Philadelphia website: The Official Trail of Philadelphia's Historic District.
Museums
Barnes Foundation: one of the best collections of impressionist art you can find anywhere.
Rodin Museum: a fantastic museum housing many works by this creative sculptor.
Philadelphia Museum of Art: aside from the art, this museum is also famous for its steps; run up them and unleash your inner Rocky.
Museum of the American Revolution
National Museum of American Jewish History
Flora and Fauna
Tyler Arboretum: all guests have access to the arboretum all day on Sunday, but this can also be a good activity for Saturday. There are miles of hiking trails and nature walks.
Ridley Creek State Park: this is the state park in which Tyler Arboretum is located, and it is also a great option to get out into nature.
Shofuso Japanese House and Garden: a wonderful traditional Japanese garden.
Unusual
Magic Gardens: a huge mosaic installation by artist Isaiah Zagar, and worth a walk through.
Eastern State Penitentiary: “this castle is a prison.”
Mutter Museum: medical oddities, including Einstein's brain.
Masonic Temple of Philadelphia: per the 1873 New York Times, this is “the largest, costliest, and most magnificent structure consecrated to Masonry in the World.”
Where: Both the ceremony and reception will be held at Tyler Arboretum near Philadelphia, Pennsylvania.
The exact address is 515 Painter Road, Media, PA. (Click for Google Maps link.)
Time: Please plan to arrive by 4pm.
Attire: Semi-formal / Cocktail
When: 10pm until late
Where: Duffer's Pub, 996 Baltimore Pike, Concordville, PA (Click for Google Maps link.)
Note that this is located very close to the Staybridge Suites Hotel.
The bar will provide a shuttle throughout the night from the bar to the hotel.


{{'text.name' | translate}}
{{upstream['name']}}
{{'text.id' | translate}}
{{upstream['id']}}
{{'text.created_at' | translate}}
{{upstream['created_at'] * 1000 | date:'medium'}}
{{'upstream.dialog.algorithm' | translate}}
{{upstream['algorithm']}}
{{'upstream.dialog.certificate' | translate}}
{{ upstream?.client_certificate?.id }}
{{'upstream.dialog.slots' | translate}}
{{upstream['slots']}}
{{'upstream.dialog.hash_on' | translate}}
{{upstream['hash_on']}}
{{'upstream.dialog.hash_on_header' | translate}}
{{upstream['hash_on_header']}}
{{'upstream.dialog.hash_on_cookie' | translate}}
{{upstream['hash_on_cookie']}}
{{'upstream.dialog.hash_on_cookie_path' | translate}}
{{upstream['hash_on_cookie_path']}}
{{'upstream.dialog.hash_fallback' | translate}}
{{upstream['hash_fallback']}}
{{'upstream.dialog.hash_fallback_header' | translate}}
{{upstream['hash_fallback_header']}}
{{'service.dialog.host' | translate}}
{{upstream['host_header']}}
{{'upstream.dialog.health_target' | translate}}
{{'upstream.dialog.threshold' | translate}}
{{upstream?.healthchecks?.threshold}}
{{'upstream.dialog.health' | translate}}
{{ 'target.health_' + upstreamHealth?.data?.health | translate}}
{{'upstream.targets' | translate}}
{{'upstream.dialog.health_active' | translate}} 0 || upstream?.healthchecks?.active?.unhealthy?.interval > 0" class="accent">{{'upstream.health_active_on' | translate}} {{'upstream.health_active_off' | translate}}
{{'upstream.dialog.type_healthcheck' | translate}}
{{upstream?.healthchecks?.active?.type}}
{{'upstream.dialog.http_path' | translate}}
{{upstream?.healthchecks?.active?.http_path}}
{{'upstream.dialog.https_verify_certificate' | translate}}
{{upstream?.healthchecks?.active?.https_verify_certificate}}
{{'upstream.dialog.https_sni' | translate}}
{{upstream?.healthchecks?.active?.https_sni}}
{{'upstream.dialog.concurrency' | translate}}
{{upstream?.healthchecks?.active?.concurrency}}
{{'upstream.dialog.timeout' | translate}}
{{upstream?.healthchecks?.active?.timeout}}
{{'upstream.dialog.health_active_healthy' | translate}}
{{'upstream.dialog.http_statuses' | translate}}
{{upstream?.healthchecks?.active?.healthy?.http_statuses}}
{{'upstream.dialog.successes' | translate}}
{{upstream?.healthchecks?.active?.healthy?.successes}}
{{'upstream.dialog.interval_healthy' | translate}}
{{upstream?.healthchecks?.active?.healthy?.interval}}
{{'upstream.dialog.health_active_unhealthy' | translate}}
{{'upstream.dialog.http_statuses_unhealthy' | translate}}
{{upstream?.healthchecks?.active?.unhealthy?.http_statuses}}
{{'upstream.dialog.interval_unhealthy' | translate}}
{{upstream?.healthchecks?.active?.unhealthy?.interval}}
{{'upstream.dialog.timeouts' | translate}}
{{upstream?.healthchecks?.active?.unhealthy?.timeouts}}
{{'upstream.dialog.http_failures' | translate}}
{{upstream?.healthchecks?.active?.unhealthy?.http_failures}}
{{'upstream.dialog.tcp_failures' | translate}}
{{upstream?.healthchecks?.active?.unhealthy?.tcp_failures}}
{{'upstream.dialog.health_passive' | translate}}
{{'upstream.dialog.type_healthcheck' | translate}}
{{upstream?.healthchecks?.passive?.type}}
{{'upstream.dialog.health_active_healthy' | translate}}
{{'upstream.dialog.http_statuses' | translate}}
{{upstream?.healthchecks?.passive?.healthy?.http_statuses}}
{{'upstream.dialog.successes' | translate}}
{{upstream?.healthchecks?.passive?.healthy?.successes}}
{{'upstream.dialog.health_active_unhealthy' | translate}}
{{'upstream.dialog.http_statuses_unhealthy' | translate}}
{{upstream?.healthchecks?.passive?.unhealthy?.http_statuses}}
{{'upstream.dialog.http_failures' | translate}}
{{upstream?.healthchecks?.passive?.unhealthy?.http_failures}}
{{'upstream.dialog.tcp_failures' | translate}}
{{upstream?.healthchecks?.passive?.unhealthy?.tcp_failures}}
{{'upstream.dialog.timeouts' | translate}}
{{upstream?.healthchecks?.passive?.unhealthy?.timeouts}}


|
SAC Effects
v1.0
|
SACEffects window interface. More...
#include <SACEffects.h>
Public Member Functions | |
| SACEffects (QWidget *framework=0) | |
| SACEffects constructor. More... | |
| ~SACEffects () | |
| SACEffects destructor. | |
| void | play () |
| It starts playing input. | |
| void | pause () |
| It pauses input playback. | |
| void | reset () |
| It resets all decoding parameters, including input file. | |
| void | updateControls () |
| It updates enability of user interface controls according to the current parameters state. | |
| void | setEffect (Effect::effectID effect) |
| It sets an effect for the effect monitor. More... | |
| void | setSource (std::string filename) |
| It sets the source audio file. More... | |
| void | setBitstream (std::string filename) |
| It sets the bitstream audio file. More... | |
| void | setInput (std::string filename) |
| It sets the input audio file. More... | |
| void | setFormat (int fs, int samplesize) |
| It sets audio output format. More... | |
| void | setDuration (QLabel *label, double duration) |
| It sets a duration indicator text on an user interface label object. More... | |
| void | getDuration (QLabel label) |
| void | setUpmixType (UpmixType::upmixtype upmixtype) |
| It sets SAC parameter upmix type. More... | |
| void | setDecodingType (DecodingType::decodingtype decodingtype) |
| It sets SAC parameter decoding type. More... | |
| void | setBinauralQuality (BinauralQuality::binauralquality binauralquality) |
| It sets SAC parameter binaural quality. More... | |
| void | setHRTFModel (HRTFModel::hrtfmodel hrtfmodel) |
| It sets SAC parameter HRTF model. More... | |
Public Attributes | |
| const int | fs = 44100 |
Definition at line 76 of file SACEffects.h.
|
explicit |
| framework | SACEffects user interface object |
Definition at line 12 of file SACEffects.cpp.
| void SACEffects::setBinauralQuality | ( | BinauralQuality::binauralquality | binauralquality | ) |
| binauralquality | binaural quality |
Definition at line 401 of file SACEffects.cpp.
| void SACEffects::setBitstream | ( | std::string | filename | ) |
| filename | file path |
Definition at line 233 of file SACEffects.cpp.
| void SACEffects::setDecodingType | ( | DecodingType::decodingtype | decodingtype | ) |
| decodingtype | decoding type |
Definition at line 380 of file SACEffects.cpp.
| void SACEffects::setDuration | ( | QLabel * | label, |
| double | duration | ||
| ) |
| label | user interface object where to indicate duration |
| duration | input audio file duration [s] |
Definition at line 321 of file SACEffects.cpp.
| void SACEffects::setEffect | ( | Effect::effectID | effect | ) |
| effect | selected effect |
Definition at line 182 of file SACEffects.cpp.
| void SACEffects::setFormat | ( | int | fs, |
| int | samplesize | ||
| ) |
| fs | signal sampling frequency |
| samplesize | signal sample size |
Definition at line 307 of file SACEffects.cpp.
| void SACEffects::setHRTFModel | ( | HRTFModel::hrtfmodel | hrtfmodel | ) |
| hrtfmodel | HRTF model |
Definition at line 423 of file SACEffects.cpp.
| void SACEffects::setInput | ( | std::string | filename | ) |
| filename | file path |
Definition at line 266 of file SACEffects.cpp.
| void SACEffects::setSource | ( | std::string | filename | ) |
| filename | file path |
Definition at line 202 of file SACEffects.cpp.
| void SACEffects::setUpmixType | ( | UpmixType::upmixtype | upmixtype | ) |
| upmixtype | upmix type |
Definition at line 353 of file SACEffects.cpp.
| const int SACEffects::fs = 44100 |
signal sampling frequency [Hz]
Definition at line 79 of file SACEffects.h.


List of my Favorite Video Games
Here is a list of my favorites Video Gmes
These Games are:
Far Cry 5,
Call of Duty,
Minecraft,
Fallout, and many more


{% extends "main_app/common.html" %} {% load static %} {% block content %}
Welcome to Rescue, An initiative to fight against the Heinous crimes against Women happening in the society.The most active way to inform that You are in Danger and need HELP with your Current Location. "Fight Back! Be Alert!" is our Motto and we're dedicated to providing You the very best Technological measures to ensure your Security for 24X7. Women can rely on the Website so that they can be given HELP as soon as possible. This is an approach to beat the crime rate against Women increasing in the society.We hope that our services make You feel Stronger & Safer for odd times.
Bachelor of Technology (B.Tech)
Computer Science Engineering (CSE)
Role: Backend
Bachelor of Technology (B.Tech)
Computer Science Engineering (CSE)
Role: Frontend


MERS patients {border-style respiratory px;} #ffffff;} risk Accessed Available at: Jun contact infected infection tool East Health Middle airborne emergency exposure health patient prior public symptom virus Ebola Koenig appropriate case cases countries px; {font-family CDC Emergency disease font-size healthcare reported syndrome use Figure Identify-Isolate-Inform Public acute camels close confirmed days department double; infectious isolation management severe symptoms Arabia Arabian MERS-CoV MERS. Medicine Patients Respiratory Saudi border-color border-width contagious criteria having home immediately local outbreak person personnel physicians potential precautions quarantine solid; transmission {font-style {font-weight Department Disaster June Peninsula Prevention Syndrome WestJEM bold control courier; dromedary em; emerging hospital illness. include initial isolated laboratory monitoring persons pt;} rapid room spread suspected transmitted