Core renderer for the application
More...
#include <Renderer.h>
Inherits Fling::Singleton< Renderer >.
|
| static Renderer & | Get () |
| |
| | Singleton ()=default |
| | Every singleton must have a default constructor so that explicit creation and destruction of them is maintained. More...
|
| |
Core renderer for the application
◆ ChooseSwapChainPresentMode()
| VkPresentModeKHR Fling::Renderer::ChooseSwapChainPresentMode |
( |
const std::vector< VkPresentModeKHR > & |
t_AvialableFormats | ) |
|
|
private |
Choose a present mode for the swap chain based on the given formats.
Prefer VK_PRESENT_MODE_MAILBOX_KHR If none are available, than return VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_IMMEDIATE_KHR based on support
- Parameters
-
| Vector | of available formats |
- Returns
- Preferred present mode from the available formats
◆ ChooseSwapChainSurfaceFormat()
| VkSurfaceFormatKHR Fling::Renderer::ChooseSwapChainSurfaceFormat |
( |
const std::vector< VkSurfaceFormatKHR > & |
t_AvailableFormats | ) |
|
|
private |
Choose a swap chain format based on the available formats.
Prefer to format that has VK_FORMAT_B8G8R8A8_UNORM and VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, otherwise get the first available.
- Parameters
-
| Available | swap chain formats |
- Returns
- Best swap chain surface formate based on the available ones
◆ ChooseSwapExtent()
| VkExtent2D Fling::Renderer::ChooseSwapExtent |
( |
| ) |
|
|
private |
Determine the best match extents based on our window width and height.
- Returns
- Extents with the best matching resolution
◆ CleanupFrameResources()
| void Fling::Renderer::CleanupFrameResources |
( |
| ) |
|
|
private |
◆ CreateCommandBuffers()
| void Fling::Renderer::CreateCommandBuffers |
( |
| ) |
|
|
private |
◆ CreateCommandPool()
| void Fling::Renderer::CreateCommandPool |
( |
| ) |
|
|
private |
Create the command pool to be sent every frame.
◆ CreateDescriptorLayout()
| void Fling::Renderer::CreateDescriptorLayout |
( |
| ) |
|
|
private |
◆ CreateDescriptorPool()
| void Fling::Renderer::CreateDescriptorPool |
( |
| ) |
|
|
private |
◆ CreateDescriptorSets()
| void Fling::Renderer::CreateDescriptorSets |
( |
| ) |
|
|
private |
◆ CreateFrameBuffers()
| void Fling::Renderer::CreateFrameBuffers |
( |
| ) |
|
|
private |
Create the frame buffers for use by the swap chain.
◆ CreateGameWindow()
| void Fling::Renderer::CreateGameWindow |
( |
const UINT32 |
t_width, |
|
|
const UINT32 |
t_height |
|
) |
| |
Init GLFW and create the game window
- Parameters
-
| t_width | Width of the window |
| t_height | Height of the window |
◆ CreateGraphicsPipeline()
| void Fling::Renderer::CreateGraphicsPipeline |
( |
| ) |
|
|
private |
Create the graphics pipeline (IA, VS, FS, etc)
◆ CreateRenderPass()
| void Fling::Renderer::CreateRenderPass |
( |
| ) |
|
|
private |
Create the frame buffer that will be used by the graphics pipeline.
◆ CreateShaderModule()
| VkShaderModule Fling::Renderer::CreateShaderModule |
( |
std::shared_ptr< File > |
t_ShaderCode | ) |
|
|
private |
Create a shader module based on the given shader code.
- Parameters
-
- Returns
- Shader module from the given code
◆ CreateSyncObjects()
| void Fling::Renderer::CreateSyncObjects |
( |
| ) |
|
|
private |
Create semaphores and fence objects.
◆ CreateUniformBuffers()
| void Fling::Renderer::CreateUniformBuffers |
( |
| ) |
|
|
private |
◆ DrawFrame()
| void Fling::Renderer::DrawFrame |
( |
| ) |
|
◆ GetCommandPool()
| const VkCommandPool& Fling::Renderer::GetCommandPool |
( |
| ) |
const |
|
inline |
◆ GetCurrentWindow()
| FlingWindow* Fling::Renderer::GetCurrentWindow |
( |
| ) |
const |
|
inline |
◆ GetGraphicsQueue()
| const VkQueue& Fling::Renderer::GetGraphicsQueue |
( |
| ) |
const |
|
inline |
◆ GetLogicalDevice()
◆ GetLogicalVkDevice()
| const VkDevice& Fling::Renderer::GetLogicalVkDevice |
( |
| ) |
const |
|
inline |
Get the logical graphics Device object.
- Returns
- const ref to VkDevice
◆ GetPhysicalDevice()
◆ GetPhysicalVkDevice()
| const VkPhysicalDevice& Fling::Renderer::GetPhysicalVkDevice |
( |
| ) |
const |
|
inline |
Get the Physical Device object used by this renderer.
- Returns
- const VkPhysicalDevice&
◆ GetSwapChain()
| Swapchain* Fling::Renderer::GetSwapChain |
( |
| ) |
const |
|
inline |
◆ GetVkSurface()
| const VkSurfaceKHR& Fling::Renderer::GetVkSurface |
( |
| ) |
const |
|
inline |
◆ Init()
| void Fling::Renderer::Init |
( |
| ) |
|
|
overridevirtual |
◆ InitGraphics()
| void Fling::Renderer::InitGraphics |
( |
| ) |
|
|
private |
Init the current graphics API
◆ PrepShutdown()
| void Fling::Renderer::PrepShutdown |
( |
| ) |
|
Prepare for shutdown of the rendering pipeline, close any open semaphores.
◆ QuerySwapChainSupport()
Check the swap chain support of a given device.
- Parameters
-
| The | device to check support on |
- Returns
- Details of the the swap chain support on this device
◆ RecreateFrameResources()
| void Fling::Renderer::RecreateFrameResources |
( |
| ) |
|
|
private |
Re-create the image views, render passes, and command buffers.
◆ SetFrameBufferHasBeenResized()
| void Fling::Renderer::SetFrameBufferHasBeenResized |
( |
bool |
t_Setting | ) |
|
|
inline |
◆ Shutdown()
| void Fling::Renderer::Shutdown |
( |
| ) |
|
|
overridevirtual |
◆ Tick()
| void Fling::Renderer::Tick |
( |
| ) |
|
Happens before draw frame.
Update the window
◆ UpdateUniformBuffer()
| void Fling::Renderer::UpdateUniformBuffer |
( |
UINT32 |
t_CurrentImage | ) |
|
|
private |
Update the uniform buffer data.
Called during DrawFrame
- Parameters
-
| t_CurrentImage | The current image index that we are using |
◆ CurrentFrameIndex
| size_t Fling::Renderer::CurrentFrameIndex = 0 |
|
private |
◆ m_camera
◆ m_CommandBuffers
| std::vector<VkCommandBuffer> Fling::Renderer::m_CommandBuffers |
|
private |
◆ m_CommandPool
| VkCommandPool Fling::Renderer::m_CommandPool |
|
private |
◆ m_CurrentWindow
| FlingWindow* Fling::Renderer::m_CurrentWindow = nullptr |
|
private |
◆ m_DepthBuffer
◆ m_DescriptorPool
| VkDescriptorPool Fling::Renderer::m_DescriptorPool |
|
private |
◆ m_DescriptorSetLayout
| VkDescriptorSetLayout Fling::Renderer::m_DescriptorSetLayout |
|
private |
Pipeline layout stores uniforms (global shader vars)
◆ m_DescriptorSets
| std::vector<VkDescriptorSet> Fling::Renderer::m_DescriptorSets |
|
private |
◆ m_FrameBufferResized
| bool Fling::Renderer::m_FrameBufferResized = false |
|
private |
Used to determine if the frame buffer has been resized or not.
◆ m_GraphicsPipeline
| VkPipeline Fling::Renderer::m_GraphicsPipeline |
|
private |
◆ m_ImageAvailableSemaphores
| std::vector<VkSemaphore> Fling::Renderer::m_ImageAvailableSemaphores |
|
private |
◆ m_InFlightFences
| std::vector<VkFence> Fling::Renderer::m_InFlightFences |
|
private |
◆ m_Instance
| Instance* Fling::Renderer::m_Instance = nullptr |
|
private |
◆ m_LogicalDevice
◆ m_PhysicalDevice
◆ m_PipelineLayout
| VkPipelineLayout Fling::Renderer::m_PipelineLayout |
|
private |
◆ m_RenderFinishedSemaphores
| std::vector<VkSemaphore> Fling::Renderer::m_RenderFinishedSemaphores |
|
private |
◆ m_RenderPass
| VkRenderPass Fling::Renderer::m_RenderPass |
|
private |
◆ m_Surface
| VkSurfaceKHR Fling::Renderer::m_Surface = VK_NULL_HANDLE |
|
private |
Handle to the surface extension used to interact with the windows system.
◆ m_SwapChain
| Swapchain* Fling::Renderer::m_SwapChain = nullptr |
|
private |
◆ m_SwapChainFramebuffers
| std::vector<VkFramebuffer> Fling::Renderer::m_SwapChainFramebuffers |
|
private |
◆ m_TestImage
| std::shared_ptr<class Image> Fling::Renderer::m_TestImage |
|
private |
◆ m_TestModel
| std::shared_ptr<Model> Fling::Renderer::m_TestModel |
|
private |
◆ m_UniformBuffers
| std::vector<Buffer*> Fling::Renderer::m_UniformBuffers |
|
private |
◆ MAX_FRAMES_IN_FLIGHT
| const int Fling::Renderer::MAX_FRAMES_IN_FLIGHT = 2 |
|
staticprivate |
The documentation for this class was generated from the following files:


<lcPlanTitle>
The <lcPlanTitle> provides a title for a specific module, lesson, or section of the course that this plan describes.
Category: Learning and training: common content elements


Money Play. How should Red play 44?
pips Red=144 White=139
(CorrectAnswer= 0/0, ErrorScore= 0)
After bar/21 I think most people would find 9/5*/1* here. The question is the last 4.
After most sequences Red will be doubling next turn and White will be passing and Red will not have to cover the blot on his ace-point. Therefore 10/6 is an overplay and Red may as well protect against White's 55 joker by keeping his 10-pt. 20/16 is the correct play.
Perhaps surprisingly, XG rates 10/6 with the final 4 as very close to a blunder. Always remember to consider imminent cube action when making a play and particularly if you have rolled a joker, before which cube action seemed a long way off.
After most sequences Red will be doubling next turn and White will be passing and Red will not have to cover the blot on his ace-point. Therefore 10/6 is an overplay and Red may as well protect against White's 55 joker by keeping his 10-pt. 20/16 is the correct play.
Perhaps surprisingly, XG rates 10/6 with the final 4 as very close to a blunder. Always remember to consider imminent cube action when making a play and particularly if you have rolled a joker, before which cube action seemed a long way off.
1. Cubeful 2-ply bar/21 20/16 9/5*/1* Eq.: +0.883 0.692 0.409 0.013 - 0.308 0.078 0.003 2. Cubeful 2-ply bar/21 10/6 9/5*/1* Eq.: +0.822 (-0.061) 0.676 0.411 0.010 - 0.324 0.079 0.002 3. Cubeful 2-ply bar/21 20/16(2) 9/5* Eq.: +0.701 (-0.182) 0.674 0.340 0.016 - 0.326 0.094 0.003 4. Cubeful 2-ply bar/21 20/16 10/6 9/5* Eq.: +0.678 (-0.206) 0.676 0.352 0.016 - 0.324 0.086 0.003 5. Cubeful 0-ply bar/21 10/6(2) 9/5* Eq.: +0.577 (-0.306) 0.626 0.311 0.012 - 0.374 0.089 0.003


Composite Types¶
Composite types are complex types used as data types, but they are not identified.
Besides their lack of identification, composite types are much like item types. They consist of definitions and properties. Properties can be simple types, complex composite types, or relationships to item types.
Each composite type is defined in a folder located at
baseDirectory/CompositeTypes/TypeName
. Within this folder, several
files provide information about the type.
readme.markdown¶
The baseDirectory/CompositeTypes/TypeName/readme.markdown
file contains text
to describe your type.
See also
See https://daringfireball.net/projects/markdown/basics for a primer on using markdown to format text.
TypeName.csv¶
The baseDirectory/CompositeTypes/TypeName/TypeName.csv
file
describes the properties of the type. Be sure to replace
TypeName with the name of the type.
The CSV file contains the following columns.
- Name
The name of the property.
Note
An type can include a property with the same name as a property in another type. However, the data types of the properties must be the same.
- DataType
The data type of the property. The data type can be one of:
- The name of a simple, primitive type as listed in Primitive Types
- The name of a complex type defined as a composite type
- The name of an item type
- MinCardinality
- The minimum number of occurrences of the property that an instance can include. Use 0 to mark the property as optional. Use 1 to mark the property as required.
- MaxCardinality
- The maximum number of occurrences of the property that an instance can include. Use 1 if the property can only appear a single time. Use n to allow an unlimited number of occurrences.
- Description
- The description of the property. This is included in the generated documentation, and as comments or annotations in many of the other publishers.
- MinLength, MaxLength, Enumeration, Pattern, MinInclusive, MinExclusive, MaxInclusive, MaxExclusive
- Used to restrict the allowed values of properties of simple, primitive types as described in Primitive Types.
- DeprecatedNamespace, DeprecatedElementOrAttribute, DeprecatedChoiceGroup
- Deprecated. Used only for DDI 3.x backward compatibility.
Extends.*¶
The baseDirectory/CompositeTypes/TypeName/Extends.BaseTypeName
file acts as
a marker to indicate that the type derives from another type. Derived
types inherit all properties from their parent type. Be sure to replace
BaseTypeName with the name of another type.
This file is optional; it is only needed if the type derives from another type.


This example searches for jQuery locally at ../node_modules/jquery/dist/jquery.min.js
, but
jQuery was not found there. Please eather install jQuery (via npm or manually)
or modify this HTML file and change the src attribute of the script tag loading jQuery
to specify a different local path or a CDN URL.
This example searches for jQuery.scrollTo locally at ../node_modules/jquery.scrollto/jquery.scrollTo.min.js
, but
it was not found there. jQuery.scrollTo is an optional dependency:
The show/HideSection() plug-ins will still work, but auto-scrolling to a certain position in the viewport
will not be animated (smooth scrolling) without the scrollTo plug-in, but instead the
viewport will instantly "jump" to the target position.
Select a “function to test when scrolling” above and then
scroll blocks below horizontally in order to update the status displays. The colors of the
large blocks A through E as well as the following "true"/"false" displays
will then update to represent the current return value (boolean) of the selected
plug-in function.
Along with the status displays, you'll also find buttons which will trigger
an alignment action. The function to execute when pushing those buttons can also
be selected above (“function to test by action button”).
$("#A").…
$("#B").…
$("#C").…
$("#D").…
$("#E").…


| Flight Number | From | To | Departure | Arrival | Total |
|---|---|---|---|---|---|
| {{passenger.flight_no.flight_no}} | {{passenger.flight_no.source}} | {{passenger.flight_no.destination}} | {{passenger.flight_no.departure_time}} | {{passenger.flight_no.arrival_time}} | {{passenger.flight_no.cost}} |
| GRAND TOTAL (USD) | {{passenger.flight_no.cost}} |
Thank you for flying with Air Starlines.


As a student, I want to create an About Me page to demonstrate my skills with HTML and JavaScript.
I currently work for a Canadian company called HERO. They manufacture paint auto-tinters, to which I install and repair. I cover 6 states, Washington, Oregon, Montana, Idaho, Alaska, and occasionally, Wyoming. The region I amm in, is one of the the slowest in the country, and I’ve gotten bored. So I’m here, at CodeFellows, to change careers to something that I want to do, not something that I need to do in order to live.
In my free time, I hang out with my bf, friends, and my mother. However, most of the time I’m doing other things to keep my mind busy, such as video games, designing and building a new “jack in the box”, and now school. I’m also getting supplies together to create my own whiskey. It’s a birthday present for my nephew, and for my sister and her husband, when he turns 21. But if I’m going to let it age for 20 years, it may be a few years late. I already have the storing place set. Just need to build the distiller and create the mash. Also still debating on what size of barrels I’m going to use. Since they come in many sizes. If I have enough mash, I’m more than happy to make a few smaller barrels for people to have and let sit, or they can drink it straight up like moonshine.


--- layout: home front_image_path: /assets/images/ru-cover-image.jpg front_image_caption: >- R-U-here is an exploration into the past, present and the future of Rural & Urban living and how changes might effect us all. Throughout October 2019 R.U will be on the Buses. They connect the Rural and the Urban as well as taking us through a landscape that we hardly engage with ond our journey to and from home, work & play. R.U will be traveling on the buses and finding out more... We will be posting our findings on Instagram main_image_path: /assets/images/ru-cover-image.jpg main_image_caption: >- "R-U-here is an exploration into the past,present and the future of Rural & Urban living and how changes might effect us all. The explorations will be through walks,talks,exhibitions,performance,games,humor,Art, Architecture and... with people. This is a holding page- A full website will follow.please follow us on social media for the moment. show_carousel: false show_blog: true posts_number: 3 carousel: - image: /assets/images/advert-impregnable.jpg caption: alink: - image: /assets/images/20190101_203049 copy.jpg caption: Urban alink: /gallery/test/ - image: caption: alink: _options: layout: hidden: true image_path: uploads_dir: 'assets/images/:year' width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg main_image_path: uploads_dir: 'assets/images/:year' width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg content: uploads_dir: 'assets/:year' _comments: front_image_path: Cover image front_image_caption: Alt text for cover image carousel: Edit the slideshow show_carouse: Show the slideshow show_blog: Show your latest posts on the homepage posts_number: How many posts to show alink: Optional web link from the slide caption: optional caption --- {% if page.front_image_path and page.show_front_image %} {% endif %}
R-U-here is an exploration into the past, present and the future of Rural & Urban living and how changes might effect us all.
Throughout October 2019 R.U explored bus routes in/out of Oxford. They connect the Rural and the Urban as well as taking us through a landscape that we hardly engage with on our journey to and from home, work & play.
R.U will be traveling on the buses and finding out more...
R-U is a follow-on project of ArtWash
ArtWash is an inter-social creative space that started in a working Launderette in Oxford.


- Blog Posts
- Technical
- VC, Git and Github
- HTML & CSS
- Arrays & Hashes
- Ruby Enumerable Magic
- Intro to Ruby Classes
- FP vs. OOP
- Loops: JS vs. Ruby
- Dynamic vs. Static Typed languages
- Cultural
- DBC warm up
- Abstract Sequential
- Internet & Bias
- Pairing & Feedbacks
- Stereotype Threat
- Values To Live By
- Situations of Conflict
- Cheat Sheets
- SQL
12/20/2014
Let's git started!
This first week, I learned a lot about version control software such as Git and Github, and became acquainted with manipulating my Desktop (operating files, moving across directories, etc) from the command line. Whoa! The command line is not nearly as esoteric as I thought. It just comes down to learning the basic commands like "ls", "pwd", 'cd', "mv", "mkdir", "touch" & more!
Here is a link to all of the useful commands you can use:
It makes things so much easier in many ways, and of course, I can look pretending I'm a pro, doing very simple things (like moving folders) that appear hard to the outside eye.
Sam becoming Neo... loading 10%....
Aside from the command line, we dug deep into the concepts of version control, git and Github.
Version control allows you to keep track of the edits you make to a project. This can be useful in situations where you realized that you made a few mistakes and want to go back to an older version of your project. In most cases, you can't remember exactly where you made the changes- how practical would it be if you could see the history of all your edits? This would allow you to pinpoint exactly where and when any edits was made, thus you have better control over your project as a whole. This is precisely what "version control" is - it's a software that allows you to have control for tracking the different versions of your project.
It's important to note that instead of tracking and saving every unit of changes in your projet (such as every letter typed- making it quite overwheling to track anything), the user chooses when and how to bundle up - aka commit- her edits, in order to save them altogether. In a way, you can think of version control as a 'saving point management program'.
Finally, version control allows more than one user to easily collaborate with you on the same project. Pulling edits from the original project to the one you are working on (the "cloned" version) allows your edits not to overlap with your coworkers' edit. This can save a considerable amount of time as it avoids constant communication to let the others know which part of the project you are working on.
Git is an example of a version control system. Well, actually, it is the most popular, and widely used version control system. It allows you to track your changes locally (on your own machine), through the command line window. The commands that git uses are very intuitive and easy to remember, such as "git status" to check the status of a project, or "git add ." to add the last edits made to a project. Even if you are unsure about a certain command, you can always type 'help' or 'man' in the command line to receive their complete instructions.
What makes git so wonderful, is that in additioning to track your changes locally, it allows you to interact with online platforms such as Github (which will talk about in just a second), to download, synchronize, push, or pull content between the user's local files and her remote ones. This means that any changes you make to your file, or anytime you create a 'saving point" locally, you only need to send a command through git for your edits to show online! And that's usually how people will collaborate together on a project. Most often, they don't have access to what is going on in your machine (unless information flows completely openly with members of the same network, but most likely, it won't be the case, even in a professional environment) , so you need some type of online version control system to keep everyone at loop.
Git calls the online platform it operates on the 'remote location', and you can expect a lot of back and forth between local and remote- pulling updates files to your local machine, pushing your updates to the remote file that everyone has access to, etc. Note that a "remote location" of a file can be anything from a Github repository, to an email inbox. It's also known as a 'cloud' storage.
After saving your changes into your folder, the general flow of Git is:
#checks status of file
#adds and bundles up your changes to the staging area
#officializes and applies your bundled up changes to your local computer.
#pushes changes to your remote location
Here is how I typically operate Git in the Terminal:
Here is a simple guide for using Git.
Github is an online platform that allows users to code socially using version control. In a way, it is an online equivalent of git, meaning that it provides storage and version control through the internet, instead of your local machine.
It is also useful for storing your code, because it allows you to access it from any machine that has internet. You simply need to log into Github. Github files can also be used locally through git (by downloading, or 'cloning' the files from the terminal using git) but it is important to synchronise all the changes you make.
Finally, Github is a great way to improve your code if you are willing to accept inputs and recommendations from others. This is called open source, and by making your project (Github calls it 'repository') public to others, (or private to a selected few) others can fork their own clone of your project, and improve your code before submitting them back for your approval.


{% extends "base.html" %} {% block extra_head %} {% endblock %} {% block content %}
If you want to take advantage of the data that this applications puts out, feel free to use the weedprices API which is described below:
| URL: | http://weedprices.biz/stats.json |
|---|---|
| Description: |
A JSON response with the average drug prices for all supported drugs.
|
| Response: |
[ { date: "2013-08-11T13:45:55.394736", price:<PHONE_NUMBER>590913, drug: "mdma" }, { date: "2013-08-11T13:46:01.988340", price:<PHONE_NUMBER>963037, drug: "weed" } ] |
| URL: | http://weedprices.biz/listings.json?drug=[drug] |
|---|---|
| Description: | A JSON response with all listings for a given drug. Currently supported drugs: 'weed', 'mdma'
|
| Response: |
{ last_updated: "2013-08-11T16:04:21.341967", listings: [ { thumb: "3fab3d8b724954fe01cc8db7aba41807", title: "10 grams of high quality MDMA", url: "http://silkroadvb5piz3r.onion/silkroad/item/574132225a", country: "DE", price: 2.6343, seller: "Sukey(97)", quantity: 0.3527336860670194 }, { thumb: "51be77eb53d1b03a82c1efd30eb6420c", title: "SuperTrips 84% Pure MDMA (10g)", url: "http://silkroadvb5piz3r.onion/silkroad/item/ad6fe0c724", country: "US", price: 5.1912, seller: "UnderGroundSyndicate(98)", quantity: 0.3527336860670194 }, ... ], drug: "MDMA", worldwide_avg_per_ounce:<PHONE_NUMBER>729887, bitcoin_price: 100.69, outliers: 62 } |


Intern position in the field of Computer Science.
About:I am currently a sophomore studying Computer Science at Santa Clara University, CA.
Courses Taken:Assist students with assignments, programming projects, and understanding concepts in Object-Oriented Programming and Data Structures
Learnt basic web development where I built interactive web pages using HTML, CSS, JavaScript such as uploading images and applying image filters I created.
Learnt website programming to build interactive web pages where I learnt more HTML, CSS, JavaScript as well as how to use the CSS library - Bootstrap as well as jQuery.
Learnt the python programming essentials and fundamentals
Developed skills to maipulate data stored in files.
Learnt how to read, store, and process tabular data, learnt how to use CSV files and how to organize and sort data.
Data structure implementations, games, and other demonstrations of object-oriented principles.
A simulation of a professor's office hours that gives wait times for students, priority, and student records that include their names, number of office hours attended, and topics for which they asked questions.
Computes top batting statistics by year and by career through analysis of baseball data.
Finding differences in file contents and prints out the differences and gives the location.
Webpage using HTML, CSS, JavaScript, jQuery, and Bootstrap to create an image gallery that is able to display images in order through a slideshow, pause, and restart.
Webpage using HTML, CSS, JavaScript, jQuery, and Bootstrap that can be turned to night mode that allows users to change and skip chapters in a book.
GPA: 4.00
GPA: 4.00
Current Activites
I have an interest in Data Science and potentially hope to gain insight into the field as well as the skills and knowledge required to be a part of the Data Science field.
Along with computer science, I enjoy working out, organizing, playing bridge, and swimming. When relaxing, my favorite shows to watch are Hawaii Five-0 and Chicago Med.


{% load i18n_with_welsh %} {% load dc_forms %} {% if cancelled_election.cancelled %} {% include "fragments/cancelled_election.html" %} {% else %}
{% trans "We're not aware of any upcoming elections in your area." %} {% blocktrans trimmed with council.electoral_services_phone_numbers.0 as council_phone and council.electoral_services_website as council_website %} If you think there may be elections in your area, check your local council website for more information, or contact {{ council }} on {{ council_phone }}. {% endblocktrans %}
{% endif %}


×
You have been logged out
×
There was an error, please try again.
Please log in
Username
Password
Sign in


CMLS: Constrained Multivariate Least Squares
Solves multivariate least squares (MLS) problems subject to constraints on the coefficients, e.g., non-negativity, orthogonality, equality, inequality, monotonicity, unimodality, smoothness, etc. Includes flexible functions for solving MLS problems subject to user-specified equality and/or inequality constraints, as well as a wrapper function that implements 24 common constraint options. Also does k-fold or generalized cross-validation to tune constraint options for MLS problems. See ten Berge (1993, ISBN:9789066950832) for an overview of MLS problems, and see Goldfarb and Idnani (1983) <doi:10.1007/BF02591962> for a discussion of the underlying quadratic programming algorithm.
| Version: |
1.0-0 |
| Depends: |
quadprog, parallel |
| Published: |
2018-06-10 |
| Author: |
Nathaniel E. Helwig |
| Maintainer: |
Nathaniel E. Helwig <helwig at umn.edu> |
| License: |
GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: |
no |
| CRAN checks: |
CMLS results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=CMLS
to link to this page.


Since Benjamin Franklin sat in Le Procope negotiating loans for a fledgling republic, the United States and France have had a tightly intertwined relationship. Today that relationship is strengthened by the ease with which we can travel to study and work. However, there are few funding opportunities for graduate students coming from the United States to study in France. We hope to begin to fill this gap.
As the world moves to an increasingly service oriented economy the need for high skill services grows. To be able to grasp the upper-middle class opportunities once easily within reach of the average American students today need advanced degrees and international experience. To help American students to compete on the international job market we plan to offer scholarships to study at some of the most prestigious institutions in Europe.
It is not impossible for an American to study in France and it is often more affordable. However, the barriers to entry are high, with expensive plane tickets, high prices for cost of living, and complicated immigration procedures. Because of these high barriers, many students don't even consider advanced study in France. In order to encourage students to pursue advanced degrees in France, we plan to take into account one's personal financial situation alongside academic success.
You can help out by donating today.
Tuition and fees at French universities are low, but American graduate students in Frnace often don't qualify for US government loans. Alongside this, there are few scholarships geared towards Americans. You can help to encourage more American students to study in France by giving to our scholarship fund today.
If you feel like you have something more to offer, don't hesitate to contact us. We are open to partnering with individuals and organizations to better serve students.
Co-Founder
Co-Founder
Co-Founder
Having hooked and crooked our way to the top, we know how hard it is to pay for a college education.


Bloodhound
Stage - VI
USE THE LEFT TO SOLVE THE RIGHT
1. dispa1stoccurpg4(pt9-wrd5)
2. disaffor1stpg15(ln10-w8)
3. Sta1-21(par3-3:2)
i/o = Chrome + find
DOWNLOAD
OPEN


words i've said:
where computer code is a language of opportunitythe bridge :: september 10, 2018
maryland computing education summit after school providers panel
april 18, 2018
wsb-tv atlanta
atlanta, ga :: july 9, 2016
panelist, nexxt scholars annual meeting
new york, ny :: march 26, 2016
hofsta's big ideas conference
hempstead, ny :: march 9, 2016
nyu uswib tackling tech panel
new york, ny :: march 7, 2016
hackillinois keynote speech
champaign-urbana, il :: february 20, 2016
words they've said:
how music is helping abortion advocates keep up the fight
pitchfork :: july 15, 2015
jack on fire at fort reno
washington city paper :: july 24, 2015
pilot waves with alex [audio]
pilot waves :: may 31, 2015
suggestion donation with tom and ron [audio]
radio cpr :: may 15, 2015
jack on fire's new album blasts condos, catcallers, federal databases full of balls
washington city paper :: november 11, 2014


This is the host setup to receive Squid's announcement
messages. The default value, tracker.ircache.net is the only server I know
about. You can search the tracker.ircache.net database by visiting
http://www.ircache.net/Tracker/. Note that if you set cache_mgr, your email
address may be available to random people. On more than one occasion
I have seen commercial caching vendors target Squid users by
collecting their email addresses from this database. |
Syntax
|
announce_host hostname
| |
Default
|
announce_host tracker.ircache.net
| |
Example
|
announce_host some.host.name
| |
Related
|
announce_period,
announce_file,
announce_port
|
|


This page shows the settings for this extension. You can start or stop running SecureInfo extension in this page. In addtition, you might set...
Some features are not fully implemented yet. Moreover, the provided functionality can be improved in any time. They will be notified if any changes happen.


--- layout: post title: Next gen mobile interface thoughts date: 2006-02-20 00:00:00 categories: interfaces-&-interaction mobile ---
next gen mobile interface thoughts: "So, my advice to mobile UI developers – instead of designing a miniaturized version of desktop OS, better imagine that you are designing a small game. Simple, engaging and easy to play."


1.0.0
A sample class to export out of this module file.
const obj = new SampleJSExport(); obj.doSomething();
Does something..
(string)


The geometrical distance matrix calculates the euklidian distance between the 3D coordinates of all atom pairs.


This module is used for writing unit tests for your applications, you can access it with require('assert').
The API is derived from the commonjs 1.0 unit testing spec and the node.js assert module
Throws an exception that displays the values for actual and expected separated by the provided operator.
Tests if value is truthy, it is equivalent to assert.equal(true, !!value, message);
Tests shallow, coercive equality with the equal comparison operator ( == ).
Tests shallow, coercive non-equality with the not equal comparison operator ( != ).
Tests for deep equality.
Tests for any deep inequality.
Tests strict equality, as determined by the strict equality operator ( === )
Tests strict non-equality, as determined by the strict not equal operator ( !== )
Expects block to throw an error. error can be constructor, regexp or validation function.
Validate instanceof using constructor:
assert.throws(function() { throw new Error("Wrong value"); }, Error);
Validate error message using RegExp:
assert.throws(function() { throw new Error("Wrong value"); }, /value/);
Custom error validation:
assert.throws(function() {
throw new Error("Wrong value");
}, function(err) {
if ( (err instanceof Error) && /value/.test(err) ) {
return true;
}
}, "unexpected error");
Expects block not to throw an error, see assert.throws for details.
Tests if value is not a false value, throws if it is a true value. Useful when testing the first argument, error in callbacks.


Rose-Hulman Big Data
Shibberu's Course Evaluation
All past evaluations
Evaluations by Year
Select year
Evaluations by Course
update
Built with ♥ by
Keen IO
Chart visualization code modified from:
Diverging Stacked Bar Chart


We love feedback. Fill out the form below and we'll get back to you as soon as possible.
How Easy!!
Your order has been received and it is being processed. Thank You for chosing Mara Moja Pizza.
Pizza is Enroute
Your order has been received and it is being processed. It will be delivered to the location that you have indicated.
Thanks for chosing Mara Moja Pizza!
Thanks!
Thank You For Contacting Us! We'll get back to You shortly. Have a nice day!


§103-7 Capital improvements; authorizations for; emergency repairs or reconstruction, exception. All capital improvement projects requiring the use of general funds, special funds, general obligation bonds, and revenue bonds of the State, except projects covered by chapter 41D shall require authorization by the legislature and the governor. [L 1961, c 75, §1; Supp, §9-5.5; am L 1967, c 272, §1; HRS §103-7; am L 1989, c 261, §4]
Attorney General Opinions
Money appropriated for specific purpose cannot be used for another purpose. Att. Gen. Op. 70-4.


{% extends 'base.html' %} {% block seo %} {% include 'snippets/seo_tags.html' with site_name='ʕ•ᴥ•ʔ Bear Blog' type="website" title='ʕ•ᴥ•ʔ Bear Blog' url='https://bearblog.dev' description='Free, no-nonsense, super-fast blogging' image="https://bear-images.sfo2.cdn.digitaloceanspaces.com/herman-1683556668-0.png" %} {% endblock %} {% block nav %} {% endblock %} {% block content %}
This is a blogging platform where words matter most.
Your readers are protected while your content is delivered at light speed.


Patching as a Service FAQs
Service
What is the service?
As customer solutions start to expand beyond their own data centres into embracing the benefits of leveraging multi-cloud, the day-to-day management and control of operating system (OS) patching across various technology stacks and locations become highly complex and resource intensive. Patching as a Service helps to reduce these challenges, whilst increasing your level of trust and confidence in the security health of any operating systems deployed as part of your solution stack.
With Patching as a Service, we provide routine OS patch management for compute instances deployed across UKCloud's multi-cloud. It helps you accelerate business value by removing the burden of basic OS hygiene, letting you focus your attention above the operating system.
What technologies do you use?
Built on the capabilities of our Managed Monitoring as a Service, UKCloud uses a combination of patches released directly by the vendor coupled with Ivanti Security Controls, a market-leading enterprise patch management and control solution, as the key technologies to deliver Patching as a Service.
Do I get access to a dashboard or reports?
As it is assumed UKCloud will manage all patching aspects as part of this service, there are currently no dashboard or reporting features for customers to access.
How do I get alerted on events?
All alerting will be performed via a support ticket or any special escalation process agreed between UKCloud and the customer.
How does UKCloud provide urgent maintenance notifications and incident reports?
We do not envisage any scenarios that prevent UKCloud in meeting the availability KPI defined within the Service Scope for this service.
Current Service Status reports and past incident reports are published on the UKCloud Service Status page.
How does the patching cycle work?
OS vendors such as Microsoft release updates for their operating systems and associated packages in two ways:
To a specific schedule: "Patch Tuesday" / "Update Tuesday"
Ad-hoc, throughout the course of each month
As such, any patching cycle needs to take into consideration the two potential release mechanisms for updates. For our Patching as a Service, we use a batch approach with specific cut-off dates, which we consider to be the best approach to maintain consistency in UKCloud's service, provide a good level of responsiveness to patch releases and also to insulate sufficiently against erroneous upstream vendor patches or errors. This means that there's a specific cut-off after which point any patches released will not be included in that cycle (see Windows Patches vs Linux Package Updates). Rather being a limitation, this ensures that we can correctly and efficiently track activities when dealing with customer VMs.
The following diagram shows the six available cut-off dates and associated Device Groups (Device Group A to J) that customers can choose to group patch some or all of their VMs:
Note
Patching cycle is two weeks long (dates above show day number from beginning of each cycle rather than day of month).
Customers are advised to use Device Groups A to E to test patches on VMs within a representative non-production environment.
Customers are advised to use Device Groups F to J to apply patches on VMs within their production environments on the basis that no issues ave been identified in their non-production environments.
Windows patches vs Linux package updates
There are major differences between the way that Microsoft releases patches for its Windows OSs and the way that most Linux distribution vendors provide updates. The key difference is:
Microsoft releases patches for their OS (which can be either critical or recommended)
Linux vendors release patches for individual packages that make up the OS.
To make best use of existing tooling within those Linux distributions, our service will update a package rather than an individual patch (for example, the equivalent of running yum update httpd
, which will include all patches related to the httpd package).
What if the application of a patch fails?
Each patching window is followed by 18 hours of issue resolution time, in which issues during automatic patching are investigated and may involve actions such as manual application of patches, and so on. Following the end of this window, the customer will be contacted by UKCloud Support with the current state. If more time is required, this will be arranged at that point.
Management
How do I access my patching environment?
As it is assumed UKCloud will manage all OS patching aspects as part of this service, there is currently no environment for customers to access.
How do I manage my services?
As it is assumed UKCloud will manage all OS patching aspects as part of this service, there is currently no way for customers to directly manage this service.
Any changes to patch scheduling after customers have selected their patch windows will require consultation and should be requested initially by raising a ticket within the My Calls section of the Portal. Alternatively, you can contact UKCloud Support by phone or email.
Support
How do I raise a support ticket?
The secure online UKCloud Portal provides most common service management functionality. You can raise tickets within the My Calls section of the Portal. Alternatively, you can contact UKCloud Support by phone or email.
What are your service maintenance windows?
As far as possible, planned maintenance of UKCloud's infrastructure takes place periodically and at a time that aims to minimise customer impact. We provide customers with at least 14 days' advance notice of planned maintenance.
As far as possible, emergency maintenance of UKCloud's infrastructure takes place between the hours of 00:00 and 06:00 (UK local time) Monday to Friday, or between the hours of 08:00 and 12:00 (UK local time) on Saturday or Sunday, unless there is an identified and demonstrable immediate risk to a customer's environment. Whenever possible, we provide customers with at least six hours' advance notice of emergency maintenance.
Can I configure email alerts from the Portal?
Yes, you can have Portal notifications sent to you at the email address associated with your Portal login. Notifications provide information about updates to UKCloud services, in addition to maintenance and incident notifications.
Onboarding
How can I get started with the service?
Within 5 business days of accepting an order, UKCloud will create the customer's patching environment and commence patching any environments in line with the Device Group schedules they have opted-in to.
Is there a free trial?
Due to the initial complexity of configuring the patching environment, UKCloud is currently unable to offer a free trial of this service.
Billing and legal
What is the smallest unit of time I will be billed for?
The minimum unit of time for use is monthly. Part months will be rounded up.
Will I be charged for resources in a 'shut off' state?
UKCloud will continue to charge for any resources that you have elected to be monitored regardless of the state they're in. To stop any charges, you'll need to raise a ticket within the My Calls section of the Portal. Alternatively, you can contact UKCloud Support by phone or email.
How can I view billing information?
Online visibility of real-time or historic billing information is currently not available as a service provided by UKCloud.
How can I pay for the services?
Payment for UKCloud services can be made by direct bank transfer (BACS/CHAPS). You can find bank details for payment on your invoice.
What are the termination fees?
There are no termination costs for this service.
Security
How is any data related to this service kept secure?
UKCloud will deploy and manage all agents used to deliver this service, with all traffic being passed via HTTPS.
Any customer data that UKCloud collects as part of this service will never leave a UKCloud data centre or be shared with a third party.
Is there a protective monitoring service?
Protective monitoring is included with all our IaaS platforms and follows GPG 13.
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


Apache Kylin Overview
Kylin has been accepted as Apache Incubator Project on Nov 25, 2014.
Apache Kylin is an open source Distributed Analytics Engine from eBay Inc. that provides SQL interface and multi-dimensional analysis (OLAP) on Hadoop supporting extremely large datasets
What is Kylin?
- Extremely Fast OLAP Engine at Scale:
- ANSI SQL Interface on Hadoop:
- Interactive Query Capability:
- MOLAP Cube:
- Seamless Integration with BI Tools:
- Other Highlights:
- Compression and Encoding Support
- Incremental Refresh of Cubes
- Leverage HBase Coprocessor for query latency
- Approximate Query Capability for distinct Count (HyperLogLog)
- Easy Web interface to manage, build, monitor and query cubes
- Security capability to set ACL at Cube/Project Level
- Support LDAP Integration
Kylin Ecosystem
Kylin Core: Fundamental framework of Kylin OLAP Engine comprises of Metadata Engine, Query Engine, Job Engine and Storage Engine to run the entire stack. It also includes a REST Server to service client requests
Extensions: Plugins to support additional functions and features
Integration: Lifecycle Management Support to integrate with Job Scheduler, ETL, Monitoring and Alerting Systems
User Interface: Allows third party users to build customized user-interface atop Kylin core
Drivers: ODBC and JDBC drivers to support different tools and products, such as Tableau
For Developers
Source Code:
Google Group:
Developer Mail:


Amethyst vdev DataBase.Schemas.Account View Source
The main abstraction to a bank account per say.
Provides a set of functions to interact with it, since its creation
to queries about its data. Express information over the accounts
database table.
Link to this section Summary
Types
A map containing a :final_balance
key with a Decimal.t/0
value. Or nil
A standard Ecto response to DataBase.Schemas.Account
data
insertion
A DataBase.Schemas.Account
struct
Functions
It’s a Date.Range.t/0
representing the activity time span of a
given t/0
Returns the given t/0
balance
Tries to insert a t/0
struct into database
Registers a inbound DataBase.Schemas.AccountMovement.t/0
for a
given t/0
and Decimal.t/0
as amount
Registers a outbound DataBase.Schemas.AccountMovement.t/0
for a
given t/0
and Decimal.t/0
as amount
Given the :id
of t/0
and a Date.t/0
, it determines the
:initial_balance
of the first
DataBase.Schemas.AccountMovement.t/0
on this date
Checks if a given t/0
has a given Decimal.t/0
as amount
available in its balance
A sum of all inbound DataBase.Schemas.AccountMovement.t/0
:amount
for a given t/0
on a specific date
A sum of all outbound DataBase.Schemas.AccountMovement.t/0
:amount
for a given t/0
on a specific date
Given t/0
, generates a API token to it
Link to this section Types
final_balance_t() :: %{final_balance: Decimal.t()} | nil
A map containing a :final_balance
key with a Decimal.t/0
value. Or nil
.
It’s the representation for querying this specific field in the database.
A standard Ecto response to DataBase.Schemas.Account
data
insertion.
A DataBase.Schemas.Account
struct.
Link to this section Functions
activity_range(t()) :: nil | Date.Range.t()
It’s a Date.Range.t/0
representing the activity time span of a
given t/0
.
Returns the given t/0
balance.
Tries to insert a t/0
struct into database.
credit(t(), Decimal.t()) :: DataBase.Schemas.AccountMovement.response_t()
Registers a inbound DataBase.Schemas.AccountMovement.t/0
for a
given t/0
and Decimal.t/0
as amount.
debit(t(), Decimal.t()) :: DataBase.Schemas.AccountMovement.response_t()
Registers a outbound DataBase.Schemas.AccountMovement.t/0
for a
given t/0
and Decimal.t/0
as amount.
early_balance(pos_integer(), Date.t()) :: DataBase.Schemas.AccountMovement.initial_balance_t()
Given the :id
of t/0
and a Date.t/0
, it determines the
:initial_balance
of the first
DataBase.Schemas.AccountMovement.t/0
on this date.
Checks if a given t/0
has a given Decimal.t/0
as amount
available in its balance.
inbounds_on(pos_integer(), Date.t()) :: Decimal.t()
A sum of all inbound DataBase.Schemas.AccountMovement.t/0
:amount
for a given t/0
on a specific date.
outbounds_on(pos_integer(), Date.t()) :: Decimal.t()
A sum of all outbound DataBase.Schemas.AccountMovement.t/0
:amount
for a given t/0
on a specific date.
Given t/0
, generates a API token to it.


@@ -17,7 +17,7 @@ public class Application {
connections and return the desired
connections and return the desired
response.
response.
*/
*/
- public let server: ServerDriver. Type
+ public let server: Server
/**
/**
The session driver is responsible for
The session driver is responsible for
@@ -79,7 +79,7 @@ public class Application {
Make sure to append your custom `Middleware`
Make sure to append your custom `Middleware`
if you don't want to overwrite default behavior.
if you don't want to overwrite default behavior.
*/
*/
- public var globalMiddleware: [HTTPMiddleware ]
+ public var globalMiddleware: [Middleware ]
/**
/**
Available Commands to use when starting
Available Commands to use when starting
@@ -123,14 +123,14 @@ public class Application {
localization : Localization? = nil ,
localization : Localization? = nil ,
hash : HashDriver? = nil ,
hash : HashDriver? = nil ,
console : ConsoleDriver? = nil ,
console : ConsoleDriver? = nil ,
- server : ServerDriver. Type ? = nil ,
+ server : Server ? = nil ,
client : HTTPClientProtocol? = nil ,
client : HTTPClientProtocol? = nil ,
router : RouterDriver? = nil ,
router : RouterDriver? = nil ,
session : SessionDriver? = nil ,
session : SessionDriver? = nil ,
providers : [Provider] = [],
providers : [Provider] = [],
arguments : [String ]? = nil
arguments : [String ]? = nil
) {
) {
- var serverProvided: ServerDriver. Type ? = server
+ var serverProvided: Server ? = server
var routerProvided: RouterDriver? = router
var routerProvided: RouterDriver? = router
var sessionProvided: SessionDriver? = session
var sessionProvided: SessionDriver? = session
var hashProvided: HashDriver? = hash
var hashProvided: HashDriver? = hash
@@ -181,8 +181,8 @@ public class Application {
]
]
self .router = routerProvided ?? BranchRouter ()
self .router = routerProvided ?? BranchRouter ()
- self .server = serverProvided ?? DefaultServer. self
+ self .server = serverProvided ?? HTTPServer < TCPServerStream, HTTPParser < HTTPRequest > , HTTPSerializer < HTTPResponse >> ()
- self .client = clientProvided ?? HTTPClient< TCPClient > ()
+ self .client = clientProvided ?? HTTPClient< TCPClientStream > ()
routes = []
routes = []
@@ -304,12 +304,13 @@ extension Application {
do {
do {
console.output (" Server starting at \( host ) :\( port ) " , style : .info )
console.output (" Server starting at \( host ) :\( port ) " , style : .info )
// noreturn
// noreturn
- let server = try self .server .init (host : host, port : port, responder : self )
+ try self .server .start (host : host, port : port, responder : self ) { [weak self ] error in
- try server.start ()
+ self ? .console .output (" Server error: \( error ) " )
- } catch ServerError.bindFailed {
+ }
+ } catch ServerError.bind {
console.output (" Could not bind to port \( port ) , it may be in use or require sudo." , style : .error )
console.output (" Could not bind to port \( port ) , it may be in use or require sudo." , style : .error )
} catch {
} catch {
- Log.error (" Server start error: \( error ) " )
+ Log.error (" Unknown start error: \( error ) " )
}
}
}
}
}
}
@@ -356,7 +357,7 @@ extension Application {
}
}
}
}
-extension Application : HTTPResponder {
+extension Application : Responder {
/**
/**
Returns a response to the given request
Returns a response to the given request
@@ -365,10 +366,10 @@ extension Application: HTTPResponder {
- throws: error if something fails in finding response
- throws: error if something fails in finding response
- returns: response if possible
- returns: response if possible
*/
*/
- public func respond (to request : HTTPRequest ) throws -> HTTPResponse {
+ public func respond (to request : Request ) throws -> Response {
Log.info (" \( request.method ) \( request.uri .path ?? " /" ) " )
Log.info (" \( request.method ) \( request.uri .path ?? " /" ) " )
- var responder: HTTPResponder
+ var responder: Responder
let request = request
let request = request
/*
/*
@@ -389,7 +390,7 @@ extension Application: HTTPResponder {
responder = fileHander
responder = fileHander
} else {
} else {
// Default not found handler
// Default not found handler
- responder = HTTPRequest .Handler { _ in
+ responder = Request .Handler { _ in
let normal: [Method] = [.get , .post , .put , .patch , .delete ]
let normal: [Method] = [.get , .post , .put , .patch , .delete ]
if normal.contains (request.method ) {
if normal.contains (request.method ) {
@@ -408,7 +409,7 @@ extension Application: HTTPResponder {
// Loop through middlewares in order
// Loop through middlewares in order
responder = self .globalMiddleware .chain (to : responder)
responder = self .globalMiddleware .chain (to : responder)
- var response: HTTPResponse
+ var response: Response
do {
do {
response = try responder.respond (to : request)
response = try responder.respond (to : request)


The physical activity monitor (PAM) component was reintroduced to NHANES in 2011. NHANES participants were asked to wear the PAM for seven consecutive days to collect objective information on 24-hour movement when awake and asleep.
Traditionally, physical activity information has been collected in NHANES through questionnaires. Self-reported interview data, while helpful, have limitations including: 1) respondents' perceptions of activity intensity vary, and 2) periods of physical activity are difficult for respondents to recall and quantify. NHANES interview data for children and adolescents less than 16 years of age are usually provided by a proxy respondent and may be incomplete. Children may spend large amounts of time away from home and engage in sporadic periods of activity that are difficult for a proxy respondent to recall and quantify.
Objective measurement of physical activity with accelerometers had been implemented in NHANES 2003-2006. The PAM used in NHANES 2011-2014 measured acceleration (i.e., on the x-, y-, and z-axes) every 1/80th of a second (80 Hz). The device also measured ambient light levels every second (1 Hz). The 80 Hz accelerometer measurements and the 1 Hz ambient light measurements were summed over each minute, hour, and day for each participant. The following four datasets, including a header file and corresponding summary datasets at the minute, hour, and day level, were produced for the release.
A) PAM Header File (PAXHD_G):
This file contains one record for each eligible participant. It includes the information listed below:
B) Summary datasets:
Each of these minute/hour/day summary files contains multiple records
per participant (who has at least one minute of data), and provides the
information listed below:
In 2011, all participants aged 6 years and older were asked to wear a PAM for 7 consecutive days. In 2012, the target age group was extended to participants aged 3 and older. Due to disclosure concerns, only data from participants aged 6 years and older are included in the present file and released publicly. Data collected in 2012 for participants aged 3-5 years are available through the NCHS Research Data Center (RDC).
Participants were asked to wear the PAM starting on the day of their exam in the NHANES Mobile Examination Center (MEC) and to keep wearing the PAM all day and night for seven full days (midnight to midnight) and remove it on the morning of the 9th day. The device used in NHANES was the ActiGraph model GT3X+, manufactured by ActiGraph of Pensacola, FL. This model was chosen because of its ability to obtain triaxial measure, its battery life, and its water resistance. According to the manufacturer’s manual, the device is water resistant in accordance with the International Protection Rating: IPX7 and can be immersed in one meter of water for up to 30 minutes (ActiGraph, 2013). The devices were programmed to begin detecting and recording the magnitude of acceleration at 80 Hz sampling intervals at the end of the participant's MEC exam session and to stop recording data eight days later (i.e., on the 9th calendar day). The device was placed on a mesh wristband (like a watch), custom fitted for each participant's wrist and worn on the non-dominant hand, if possible. The participant was told not to do anything with the device except to wear it. If the participant needed to remove it, for any reason, he/she was instructed to put it back on the same wrist in the same orientation, as soon as possible.
A toll-free number and information materials describing the PAM were given to the participant. No activity logs, diaries, or records were kept by the participant. The PAMs were returned by mail in postage-paid padded envelopes provided to each participant.
For further details see the PAM procedures manual.
Survey staff completed an examiner training program that covered the basic operating features of the PAM, equipment operation, subject recruitment strategies, PAM device initialization, and troubleshooting. Field performance and response rates were monitored by NCHS and contractor staff.
Once PAMs were received from participants, data were downloaded from the
devices. In 2019, contractors at Northeastern University in Boston, MA
under the direction of PAM component collaborators from the National
Cancer Institute (NCI) and staff from the National Center for Health
Statistics (NCHS) reviewed these data. The data quality review
considered the properties of the raw acceleration measures, which are in
units of gravity (g). Raw signals were processed to determine
signal patterns that were unlikely to be a result of human movement. For
example, maximum or minimum values (±6 g) for extended periods
of time, spikes in values, and impossible values (e.g., no
gravitational acceleration observed, etc.). Individual 80 Hz
accelerometer measurement data were flagged as "invalid" if they met any
of the following conditions:
The header file and the minute/hour/day summary files were reviewed for outliers and unreasonable values. The criteria used for unreasonable data were based on published literature and expert judgment.
Not every eligible NHANES participant has a data file. For example, if a participant refused to wear the PAM, did not return it, or the data could not be retrieved from a damaged PAM, then the participant does not have a data file. Each participant may have up to 9 days of summary records. Per the protocol, the first and last day of data collection for each participant are partial days. For most participants, a complete data collection constitutes 193 hours. In some cases, e.g., due to battery depletion, data collection was shorter. A small proportion of participant data files include 194 hours.
The data files from the PAM were collected and downloaded in ActiGraph GT3x format. The GT3x files were converted to comma-separated value (csv) files following the mHealth format to facilitate processing the 80 Hz data. The minute/hour/day files are in the SAS format.
PAXSTS (Physical activity monitor data status)
This header file (PAXHD_G) variable indicates if the participant has PAM
data available in the summary files. Only participants with at least
one minute of 80 Hz PAM data downloaded from the returned device have
records in the summary files and have PAXSTS coded as "1 (Yes)".
PAXSENID (Accelerometer device identifier)
This header file (PAXHD_G) variable indicates the unique serial number
for the accelerometer device that the participant wore. The original
serial number from manufacture was modified with the format retained.
For budgetary reasons, accelerometer devices were reused after being
sanitized during data collection. Participants who wore the same device
would have the same device ID in their records.
PAXFDAY (Day of the week the accelerometer measurements were started)
This header file (PAXHD_G) variable indicates the day of the week when
the PAM first started to record movement measures (i.e., Sun, Mon.
etc.).
PAXLDAY (The last day when the measurements taken)
This header file (PAXHD_G) variable indicates the last day that the
participant had data recorded in the PAM. Each participant was asked to
wear the PAM and have the measurements taken for 9 days. As mentioned
above, the first and last day of data collection for each participant
are partial days.
PAXFTIME (First data point timestamp)
This
header file (PAXHD_G) variable indicates the time (in HH:MM:SS format) of
the first data point in the GT3X file. For NHANES participants, this counter
began at a prespecified time after each exam session in the exam center.
PAXETLDY (Timestamp at the end of the last day)
This header file (PAXHD_G) variable indicates the time (in HH:MM:SS
format) at the end of the last day. This was computed from start time,
number of samples, and sampling rate.
PAXHAND (PAM worn on non-dominant hand)
This header file (PAXHD_G) variable indicates whether the PAM was placed
on the wrist of the non-dominant hand (the default placement for the
PAM). The dominant hand is generally the one that person uses to write,
or for young children, the hand used for “eating, drawing, or grabbing
things”. If a non-dominant hand could not be identified, then the
default option was to place it on the left wrist.
PAXORENT (Surface orientation of the PAM when it was placed on the wrist)
This header file (PAXHD_G) variable indicates if the PAM was placed on
the dorsal or palmar surface of the wrist while in the MEC. The default
placement was the dorsal surface.
PAXDAYM, PAXDAYH, PAXDAYD (The day when PAM measurements for this minute/hour/day summary record were taken)
These variables indicate the day (1st, 2nd, 3rd, etc.) when the
measurements used for the minute/hour/day summary record were taken. For
example, a code of "2" indicating the measurements used in the summary
record were taken on the 2nd day of PAM wear by the participant.
PAXDAYWM, PAXDAYWH, PAXDAYWD (Day of the week for the minute/hour/day summary record)
These variables indicate the day of the week (Monday, Tuesday, etc.)
when the measurements used for the minute/hour/day summary record were
taken.
PAXSSNMP, PAXSSNHP, PAXSSNDP (Starting 80 Hz sample number for the minute/hour/day summary record)
The 80 Hz sample number for the first data point used for the
minute/hour/day summary record. For example, a value of "9600" in
PAXSSNMP indicates the minute summary record used data starting from the
120th second (i.e., 9600 ÷ 80 Hz = 120) since the PAM began to measure
acceleration for that participant. The sample number was identified
based on the starting time the measurements were taken, regardless of
whether it contained valid or flagged data.
PAXMSTD (Starting time of the day)
This day summary file (PAXDAY_G) variable indicates the starting time
for PAM measurement in the day in HH:MM:SS format. It usually contains
the value of “00:00:00”, except for the first day of the data collection
since the PAM was not worn at the beginning of the day. It is not
necessarily the starting time of the MIMS computation, although they
will nearly always be the same time.
PAXTSM, PAXTMH, PAXTMD (Total seconds/minutes with data in the minute file or in the hour/day files)
PAXTSM represents the total seconds of data included in the minute
summary record, it includes all seconds in this minute with data and was
computed from
the number of 80 Hz samples and rounded to an integer value. PAXTMH
and PAXTMD indicates the total minutes of data included in the hour/day
summary record, and they were determined by dividing the total seconds
of data in this hour/day by 60.
PAXAISMM, PAXAISMH, PAXAISMD (Total number of 80 Hz acceleration measurements logged during idle sleep mode)
These variables encoded the total number of the 80 Hz acceleration
measurements included in the minute/hour/day summary record that were
logged while the device was in idle sleep mode (ISM). The count includes
all data, regardless whether it was flagged as "invalid" during quality
control review. While taking measurements, the devices had their ISM on
as a battery saving feature that was a default setting of the device
firmware when NHANES data collection commenced. The device enters a
sleep or low power state after experiencing 10 seconds of inactivity
(fluctuation on the accelerometer < +/- 40 mg). After
entering this low power state, the device checks once every second to
determine if the unit has moved. While in sleep mode, the last measured
accelerometer value is written into memory at the device's preset sample
rate. Since the device is set to measure at 80 Hz, it will store the
last known accelerometer reading 80 times every second. The device will
then wake up and check for movement. If no movement (<+/- 40 mg)
was detected, this pattern would continue. Otherwise, the unit would
exit sleep mode and continue measuring in normal fashion. At very low
levels of movement, this will impact the output of the device, including
the output of MIMS-units.  This feature impacts the algorithm
design and findings on sleep/wear/non-wear classification.
PAXVMH, PAXVMD (Total number of valid minutes in the hour/day)
These two variables in the hour/day summary files indicate the total
number of minutes in the hour/day record with data considered valid
because none of the measures within that minute was flagged during the
QC review.
PAXMTSM, PAXMTSH, PAXMTSD (MIMS triaxial value for the minute/hour/day)
The MIMS-unit minute summary acceleration measurements obtained on the
x-, y-, and z-axis (i.e., PAXMXM, PAXMYM, and PAXMZM) are summed up and
released as the variable PAXMTSM in the minute summary file (PAXMIN_H).
PAXMTSM is coded as "-0.01" if any of the summary measures for the x-,
y-, or z-axis are
coded as "-0.01" which indicates that the MIMS-unit could not be
computed for that axis for that minute. The MIMS-unit calculation for
the minute was based on a universal summary metric and does not take the
"valid/invalid" QC flags into account. However, MIMS triaxial value for
the hour/day is calculated as the sum of PAXMTSM only for valid minutes
for the hour/day and is released as PAXMTSH/PAXMTSD in the hour/day
summary file (i.e., PAXHR/PAXDAY).
PAXMXM, PAXMYM, PAXMZM (MIMS x-, y-, or z-axis specific value for the minute)
These variables are included in the minute summary file (PAXMIN_G) to
indicate the acceleration measurements obtained on the x-, y-, or z-axis
after being summarized in MIMS-units. These summaries include all
seconds of data collected, regardless whether they were flagged as
"invalid" during quality control review. A -0.01 value encoded in these
variables means it was not possible to compute the MIMS-unit value
(e.g., not enough data in the one-minute window). Sometimes, the
MIMS-unit value may not be computed at
the start of the day. This is very rare. Data from this minute are not
included in the aggregation of the triaxial value of the minute
(PAXMTSM) if "-0.01" was encoded for any of the axis summaries for the
minute.
PAXPREDM (Predicted wake/sleep/non-wear status during the minute)
This variable in the minute summary file (PAXMIN_G) was established
using a machine learning algorithm with the raw data collected during
the minute. The PAM wearing status of the minute was classified as
"wake", "sleep", "non-wear", or "unknown". A "wake" status indicates the
participant is likely to be awake during the minute, and the "sleep"
status indicates the participant is likely to be asleep based on the
algorithm. The "non-wear" status indicates the algorithm suggested that
the participant did not wear the PAM during this minute, and the
"unknown" status indicates that the algorithm could not determine the
status for this minute. Please see the Analytic Notes section for
further details regarding the algorithm used in this feature.
PAXTRANM (Transition flag for wake/sleep/non-wear)
This variable in the minute summary file (PAXMIN_G) file indicates
whether the two 30-second windows used to compute the
wake/sleep/non-wear status for a given 60 seconds differ. The
wake/sleep/non-wear algorithm operates on 30-second windows. A value of
"1" indicates the two 30-second windows were not the same (i.e., a
transition in classification of wear status occurred during this
minute). For example, the first 30-second window of this minute record
was classified as sleep, but the next 30-second window of this minute
was classified as wake. The minute records that contain two 30-second
windows with different status classifications (e.g., wake/sleep, etc.)
are called transition minutes. When the minutes of wake, sleep, and
non-wear were summed at the hour and day levels, transition minutes are
flagged as "unknown".
PAXWWMH, PAXSWMH, PAXNWMH, PAXUMH (Valid wake/sleep/non-wear/unknown minutes in the hour)
These variables in the hour summary file (PAXHR_G) indicate the number
of valid minutes in the hour by algorithm assigned PAM wearing status.
PAXWWMH provides the valid wake wear minutes; PAXSWMH provides the valid
sleep wear minutes; and PAXNWMH provides the valid non-wear minutes.
PAXUMH is the number of valid minutes for which the algorithm could not
make a determination (i.e., valid data exist, but appear ambiguous to
the algorithm). The sum of values encoded in PAXWWMH, PAXSWMH, PAXNWMH,
and PAXUMH equals to the value provided in PAXVMH (total number of valid
minutes in the hour).
PAXWWMD, PAXSWMD, PAXNWMD, PAXUMD (Valid wake/sleep/non-wear/unknown minutes in the day)
These variables in the day summary file (PAXDAY_G) indicate the number
of valid minutes in the day by algorithm assigned PAM wearing status.
PAXWWMD provides the valid wake wear minutes; PAXSWMD provides the valid
sleep wear minutes; and PAXNWMD provides the valid non-wear minutes.
PAXUMD is the number of valid minutes for which the algorithm could not
make a determination (i.e., valid data exist, but appear ambiguous to
the algorithm). The sum of values encoded in PAXWWMD, PAXSWMD, PAXNWMD,
and PAXUMD equals to the value provided in PAXVMD (total number of valid
minutes in the day).
PAXLXSM, PAXLXSH, PAXLXSD (Sum of the ambient light measures for the minute/hour/day)
These variables encode the sum of the ambient light measures (lux) for
the minute/hour/day. The PAM device records lux every 1-second (1 Hz).
Only lux values from valid minutes are included in the computation. The
device was capped at a maximum value of 2500 per second. Thus, the
theoretical ranges are (0.0-150,000.0) for a minute; (0.0-9,000,000.0)
for an hour; and (0.0 to 216,000,000.0) for a day.
PAXLXSDM (Standard deviation of the ambient light measures for the minute)
This variable in the minute summary file (PAXMIN_G) is the standard
deviation of the lux recorded during the minute by the device. The
device records lux at 1 Hz. Only lux values from valid minutes are
included in the computation.
PAXQFM, PAXQFH, PAXQFD (Data quality flag for the minute/hour/day based on the quality control review)
PAXQFM indicates the number of data quality flags identified during the
minute. Zero indicates that no flags occurred. Values >0 indicate
that this minute is invalid based on the QC review. PAXQFH and PAXQFD
indicates the number of data quality flags identified during the
hour/day. Zero indicates that no flags occurred. Values >0 indicate
that one or more minutes in that hour/day was flagged as "invalid". As
mentioned above, the QC flag is not considered during the calculation of
MIMS-unit summary; however, the variable could be used as an overall
metric indicator for the quality of data on this hour/day. Since
multiple flags can exist in a single minute, this variable does not
represent the number of invalid minutes within that hour/day.
PAXFLGSM (Quality flag triggered)
This variable encodes the flag(s) triggered during quality review for
measurements taken in this minute. Since there can be multiple flags
triggered during the same minute, the values in this variable can be
recorded as a string code, for example: "A", "ABC", "EK", or "DHIJNO".
The codes for the flags are:
A = Occurrence of spikes on x-axis
B = Occurrence of spikes on y-axis
C = Occurrence of spikes on z-axis
D = Occurrence of maximum g_values on the x-axis
E = Occurrence of maximum g_values on the y-axis
F = Occurrence of maximum g_values on the z-axis
G = Occurrence of minimum g_values on the x-axis
H = Occurrence of minimum g_values on the y-axis
I = Occurrence of minimum g_values on the z-axis
J = Occurrence of contiguous maximum g_values on the x-axis
K = Occurrence of contiguous maximum g_values on the y-axis
L = Occurrence of contiguous maximum g_values on the z-axis
M = Occurrence of contiguous minimum g_values on the x-axis
N = Occurrence of contiguous minimum g_values on the y-axis
O = Occurrence of contiguous minimum g_values on the z-axis
P = Occurrence of contiguous impossible g_values for gravity (i.e., zero g for gravity)
Q = Occurrence of contiguous adjacent zero values on the z-, y-, or z-axis
R = Occurrence of contiguous adjacent identical non-zero values on the x-, y-, or z-axis
S = Occurrence of spikes on the x-axis in 1-second intervals
T = Occurrence of spikes on the y-axis in 1-second intervals
U = Occurrence of spikes on the z-axis in 1-second intervals
V = Adjacent measures to periods of invalid data
W = Interval jump in measurements on the x-axis (i.e., no measurement for the x-axis for this time period)
X = Interval jump in measurements on the y-axis (i.e., no measurement for the y-axis for this time period)
Y = Interval jump in measurements on the z-axis (i.e., no measurement for the z-axis for this time period)
The NHANES examined sample weights should always be used for analyses with PAM data. Please refer to the NHANES Analytic Guidelines and the online NHANES Tutorial for further details on the use of the NHANES sample weights and other analytic issues.
The PAM component was reintroduced to NHANES in 2011-2014 and was included in the 2012 NHANES National Youth Fitness Survey (NNYFS). A total of 16,417 persons ages 3 years and older wore the PAM during these surveys and had data available for analysis: 2011-2012 NHANES participants 6 years and older (n=6,917); 2013-14 NHANES participants 3 years and older (n=7,776); and 2012 NNYFS participants 3-15 years (1,477). In addition, PAM data were collected for 3-5 years old participants in the 2012 NHANES (n=247) as well. However, due to disclosure concerns, these data are only available in the NCHS RDC. Overall, 96% of participants with data wore the PAM until the 9th day. About 2% of the participants with PAM data wore it for less than 7 days. In NHANES and the NNYFS, approximately 99% of the PAMs in each survey were placed on the non-dominant arm of the participant.
Users should note that 1/80th of a second of data is missing in each minute. This results in 18 seconds of data missing every 24-hour day. This was due to a computational error that was not detected until post-processing the data.
Data quality review and the MIMS-unit calculation were conducted independently. As a result, MIMS-units could be computed when QC flags are found for any given minute. Similarly, if the MIMS-unit summary couldn’t be computed for a given minute (i.e., a -0.01 value was assigned to the MIMS-unit for that minute) this could possibly NOT trigger a QC flag. Data users can use the QC codes to exclude MIMS-unit data from analysis as needed.
An open-source algorithm was used with the 80 Hz accelerometer data to predict time periods of wake wear, sleep wear, or non-wear data, and assign a confidence value ranging from 0.0 to 1.0 to indicate the algorithm’s confidence that the time periods are wake wear, sleep wear or non-wear. In most cases, the algorithm identified a category for each minute. Sometimes, the algorithm was uncertain how to categorize a period of time. This resulted in unknown time periods. This algorithm used three steps.
In the first step, which used 1.5 minute windows of data, signal features (e.g., signal power, variance of orientation, orientation change) were extracted from the raw data and a machine learning algorithm was used to predict whether each 30 seconds of data was wake wear, sleep wear, or non-wear. The algorithm attempted to clarify periods of data when the accelerometer's default Idle Sleep Mode (ISM) was operating. The ISM is a battery saving feature, but unfortunately it removes useful low motion time and frequency domain information that would have enhanced the algorithm’s prediction. When ISM periods occurred in the data, the algorithm used the 10 seconds of data just before the PAM initiated the ISM as a proxy for the data automatically stored during the period of the ISM. For each segment of data identified as ISM data, the 10 seconds prior to the start of the segment (which contained some information characterizing low movement behavior with no fluctuation > 0.040 g) was copied over the ISM data (which contained no information). This should be considered as an approximation, because the 10 seconds of pre-ISM data was typically copied many times over throughout the ISM period. Testing suggested, however, that this small amount of information was valuable in differentiating waking low activity behavior, sleep, and non-wear time periods. Therefore, an algorithm optimized for this type of reversed-ISM data was used to categorize each 30-second window (using the two adjacent 10-second windows of data). Thirty-second windows were used because the algorithm's validation dataset used polysomnography for sleep detection, which was marked for sleep/wake state at 30 seconds intervals. It was necessary to perform this procedure, since the initial algorithm process (mentioned above) used 1.5-minute windows of data for all decision making, so waking low activity and sleep, or sleep and non-wear, were sometimes indistinguishable.
In the second step, minimum durations (i.e., wake wear time period <3 minutes, sleep wear period <10 minutes, and non-wear period <10 minutes) were filtered based on information from the prior and subsequent periods. Specifically, the summation of confidence values for each category from the current and adjacent periods (the periods immediately before and after the current period) was calculated. If the prior and subsequent periods had the same predicted category, and the sum of the confidence values of the prior and subsequent classes was greater than twice the sum of the confidence values of the predicted category from the current period, then predicted category of the current period was switched to the predicted category of the adjacent periods. If the prior and subsequent categories did not have the same predicted category, then the predicted category of the current category was reassigned to the predicted category of the adjacent period with the higher confidence value.
In the third step, longer periods were considered. Orientation changes were used to potentially flip some labels from non-wear to sleep, or sleep to non-wear, for longer intervals of time. This was to ensure that the final predicted sleep periods included of commonly observed periodic changes in the orientation due to body reorientation on the bed during sleep.
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 1 | 1st day of wear | 3470287 | 3470287 | |
| 2 | 2nd day of wear | 9931619 | 13401906 | |
| 3 | 3rd day of wear | 9891990 | 23293896 | |
| 4 | 4th day of wear | 9845041 | 33138937 | |
| 5 | 5th day of wear | 9787733 | 42926670 | |
| 6 | 6th day of wear | 9726650 | 52653320 | |
| 7 | 7th day of wear | 9660984 | 62314304 | |
| 8 | 8th day of wear | 9568904 | 71883208 | |
| 9 | 9th day of wear | 6243648 | 78126856 | |
| < blank > | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 1 | Sunday | 12134725 | 12134725 | |
| 2 | Monday | 11695313 | 23830038 | |
| 3 | Tuesday | 11071134 | 34901172 | |
| 4 | Wednesday | 10690811 | 45591983 | |
| 5 | Thursday | 10543693 | 56135676 | |
| 6 | Friday | 10706603 | 66842279 | |
| 7 | Saturday | 11284577 | 78126856 | |
| < blank > | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 55339200 | Range of Values | 78126856 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 2 to 60 | Range of Values | 78126856 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 4800 | Range of Values | 78126856 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 608.252 | Range of Values | 78122385 | 78122385 | |
| -0.01 | Value could not be computed | 4471 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 529.164 | Range of Values | 78122385 | 78122385 | |
| -0.01 | Value could not be computed | 4471 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 558.492 | Range of Values | 78122385 | 78122385 | |
| -0.01 | Value could not be computed | 4471 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 352.826 | Range of Values | 78122385 | 78122385 | |
| -0.01 | Value could not be computed | 4471 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 1 | Wake wear | 43080727 | 43080727 | |
| 2 | Sleep wear | 23471224 | 66551951 | |
| 3 | Non wear | 8858522 | 75410473 | |
| 4 | Unknown | 2716383 | 78126856 | |
| < blank > | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 | False | 77670850 | 77670850 | |
| 1 | True | 456006 | 78126856 | |
| < blank > | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 2500 | Range of Values | 78126856 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 1260.55 | Range of Values | 78126851 | 78126851 | |
| . | Missing | 5 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| 0 to 12 | Range of Values | 78126856 | 78126856 | |
| . | Missing | 0 | 78126856 |
| Code or Value | Value Description | Count | Cumulative | Skip to Item |
|---|---|---|---|---|
| Quality flags triggered | Value was recorded | 15616 | 15616 | |
| A | Occurrence of spikes on x-axis | 3666 | 19282 | |
| B | Occurrence of spikes on y-axis | 1051 | 20333 | |
| C | Occurrence of spikes on z-axis | 1933 | 22266 | |
| D | Occurrence of maximum g_values on the x-axis | 5 | 22271 | |
| E | Occurrence of maximum g_values on the y-axis | 19 | 22290 | |
| F | Occurrence of maximum g_values on the z-axis | 1 | 22291 | |
| G | Occurrence of minimum g_values on the x-axis | 3 | 22294 | |
| H | Occurrence of minimum g_values on the y-axis | 0 | 22294 | |
| I | Occurrence of minimum g_values on the z-axis | 0 | 22294 | |
| J | Occurrence of contiguous maximum g_values on the x-axis | 13 | 22307 | |
| K | Occurrence of contiguous maximum g_values on the y-axis | 5 | 22312 | |
| L | Occurrence of contiguous maximum g_values on the z-axis | 1 | 22313 | |
| M | Occurrence of contiguous minimum g_values on the x-axis | 32 | 22345 | |
| N | Occurrence of contiguous minimum g_values on the y-axis | 7 | 22352 | |
| O | Occurrence of contiguous minimum g_values on the z-axis | 2 | 22354 | |
| P | Occurrence of contiguous impossible g_values for gravity (i.e., zero g for gravity) | 45248 | 67602 | |
| Q | Occurrence of contiguous adjacent zero values on the z-, y-, or z-axis | 2153 | 69755 | |
| R | Occurrence of contiguous adjacent identical non-zero values on the x-, y-, or z-axis | 3724 | 73479 | |
| S | Occurrence of spikes on the x-axis in 1-second intervals | 470 | 73949 | |
| T | Occurrence of spikes on the y-axis in 1-second intervals | 137 | 74086 | |
| U | Occurrence of spikes on the z-axis in 1-second intervals | 13 | 74099 | |
| V | Adjacent measures to periods of invalid data | 35059 | 109158 | |
| W | Interval jump in measurements on the x-axis (i.e., no measurement for the x-axis for this time period) | 0 | 109158 | |
| X | Interval jump in measurements on the y-axis (i.e., no measurement for the y-axis for this time period) | 0 | 109158 | |
| Y | Interval jump in measurements on the z-axis (i.e., no measurement for the z-axis for this time period) | 0 | 109158 | |
| < blank > | Missing | 78017698 | 78126856 |


Developer Electronic Hobbyist Designer
I'm an energetic, team player with a passion for development. I enjoy solving complex problems by finding creative and innovative solutions. I've developed on various platforms, and I enjoy testing the latest technologies.
I'll also try to automate anything that takes longer than 3 minutes of my time. I have a preference for Full-Stack, but I'm ready to acquire new knowledge.


Have you wondered how search engines understand your queries and match the relevant results? How chatbot extract your intent from your questions and provide the most appropriate response?
Universal Sentence Encoder (Cer et al., 2018) is a language model that encodes text into fixed-length embeddings. It aims to convert sentences into semantically-meaningful dense real-valued vectors.
Try the demo with your own list of sentences. [read more]


on
How to split code changes
How to split code changes
We’ve all been there: when writing code, we fall victim to “while I’m here, I might as well…” and end up with a collection of code changes instead of a focused set of deltas. One term for this is shipwrights disease. It’s so easy to fix this typo, update this comment, change this dependency, etc…
There are ways out and methods to logically group changes made, depending on what’s most important.
Branches
Branches are cheap. With all the changes saved to a branch, perhaps using the savepoint pattern, you’re free to figure out what changes you want in a branch and which you do not. Since the savepoint branch keeps all your work, there’s low risk in losing changes you’ve already made.
One approach is to go back to the main or master branch, start a new branch and check out the files you need to make a focused set of changes from your savepoint branch, commit those and push them to the upstream server.
Another method is to use a new branch, starting at but not the same as your savepoint branch, and remove the changes that aren’t related to the branch’s focus.
One more option: you can always copy and paste code from the upstream server, such as GitHub, to undo unwanted changes in your local files. Not elegant but it can be quicker than other options.
Commits
Sometimes it’s easiest to show your work by having multiple commits that build on each other. Commits can also be used to theme changes: place all your comment updating in one commit, dependency updates in another, and so on.
If your changes are already made and committed locally, use the savepoint branch pattern to keep your work. Then start a new branch and manually copy in your themed changes commit by commit.
Another way is to use interactive staging to add just the parts you want into a commit. This requires all your changes to be present but not committed or staged.
How to pick
Splitting code changes via branches or commits fulfill different needs.
Separating changes into branches helps continuous integration and continuous delivery. Small changes get merged into the main or master branch regularly and deployed quickly. Small changes to deployment means a smaller area to search if problems arise.
Using commits to segregate changes is for making reviewer’s lives easier. They can look at related changes in each commit which limits the amount of time and focus required to follow a potentially complex set of changes.


- setHeader(String) - Method in class ChoiceBox
-
Sets the header of the alert
- setHeader(String) - Method in class Login
-
- setHeader(String) - Method in class MsgBox
-
Sets the header of the alert
- setHeader(String) - Method in class Prompt
-
Set the header of the alert
- setHeader(String) - Method in class QuestionBox
-
Sets the header of the alert
- setHeader(String) - Method in class Warn
-
Changes the header of the alert
- setSize(double, double) - Method in class ChoiceBox
-
Sets the size of the alert
- setSize(double, double) - Method in class ConfirmExit
-
Sets the size of the alert
- setSize(double, double) - Method in class ErrorBox
-
Sets the size of the alert
- setSize(double, double) - Method in class Login
-
Sets the size of the alert
- setSize(double, double) - Method in class MsgBox
-
Sets the size of the alert
- setSize(double, double) - Method in class Prompt
-
Sets the size of the alert
- setSize(double, double) - Method in class QuestionBox
-
Sets the size of the alert
- setSize(double, double) - Method in class Warn
-
Sets the size of the alert
- setTitle(String) - Method in class Login
-
- setWindowName(String) - Method in class Prompt
-
Sets the name of the alert window
- show() - Method in class ChoiceBox
-
Shows the alert
- show() - Method in class ConfirmExit
-
Shows the alert
- show() - Method in class ErrorBox
-
Shows the alert
- show() - Method in class Login
-
Shows the dialog and waits
- show() - Method in class MsgBox
-
Shows the alert
- show() - Method in class Prompt
-
Shows the alert
- show() - Method in class QuestionBox
-
Shows the alert
- show() - Method in class Warn
-
Shows the alert
- showNonblock() - Method in class ErrorBox
-
Shows the alert, but it isn't always on top
- showNonblock() - Method in class MsgBox
-
Shows the alert, but it isn't always on top
- showNonblock() - Method in class Warn
-
Shows the alert but isn't always on top
- style - Variable in class ChoiceBox
-
The style of the stage
- style - Variable in class ConfirmExit
-
The style of the stage
- style - Variable in class ErrorBox
-
The style of the stage
- style - Variable in class MsgBox
-
The style of the stage
- style - Variable in class Prompt
-
The style of the stage
- style - Variable in class QuestionBox
-
The style of the stage
- style - Variable in class Warn
-
The style of the stage


Note: If the test path patterns of two different anomaly threshold configurations both match some test, then the anomaly config pattern whose name comes first according to lexicographical sort order will apply. You can use this to create "higher priority" anomaly threshold configurations which applies to a smaller subset of tests.
Warning: If a test path pattern matches too many tests,
this page may time out. If you try to add a test path pattern,
e.g. ChromiumPerf/*/foo*/*/*
, and it times out,
try separating the pattern into multiple patterns that match
fewer tests, e.g. ChromiumPerf/*/foo.bar/*/*
and
ChromiumPerf/*/foo.baz/*/*.


| WRITE(2) | Linux Programmer's Manual | WRITE(2) |
ssize_t write(int fd, const void *buf, size_t count);
The number of bytes written may be less than count if, for example, there is insufficient space on the underlying physical medium, or the RLIMIT_FSIZE resource limit is encountered (see setrlimit(2)), or the call was interrupted by a signal handler after having written less than count bytes. (See also pipe(7).)
For a seekable file (i.e., one to which lseek(2) may be applied, for example, a regular file) writing takes place at the file offset, and the file offset is incremented by the number of bytes actually written. If the file was open(2)ed with O_APPEND, the file offset is first set to the end of the file before writing. The adjustment of the file offset and the write operation are performed as an atomic step.
POSIX requires that a read(2) that can be proved to occur after a write() has returned will return the new data. Note that not all filesystems are POSIX conforming.
According to POSIX.1, if count is greater than SSIZE_MAX, the result is implementation-defined; see NOTES for the upper limit on Linux.
Note that a successful write() may transfer fewer than count bytes. Such partial writes can occur for various reasons; for example, because there was insufficient space on the disk device to write all of the requested bytes, or because a blocked write() to a socket, pipe, or similar was interrupted by a signal handler after it had transferred some, but before it had transferred all of the requested bytes. In the event of a partial write, the caller can make another write() call to transfer the remaining bytes. The subsequent call will either transfer further bytes or may result in an error (e.g., if the disk is now full).
If count is zero and fd refers to a regular file, then write() may return a failure status if one of the errors below is detected. If no errors are detected, or error detection is not performed, 0 will be returned without causing any other effect. If count is zero and fd refers to a file other than a regular file, the results are not specified.
Other errors may occur, depending on the object connected to fd.
Under SVr4 a write may be interrupted and return EINTR at any point, not just before any data is written.
A successful return from write() does not make any guarantee that data has been committed to disk. On some filesystems, including NFS, it does not even guarantee that space has successfully been reserved for the data. In this case, some errors might be delayed until a future write(), fsync(2), or even close(2). The only way to be sure is to call fsync(2) after you are done writing all your data.
If a write() is interrupted by a signal handler before any bytes are written, then the call fails with the error EINTR; if it is interrupted after at least one byte has been written, the call succeeds, and returns the number of bytes written.
On Linux, write() (and similar system calls) will transfer at most 0x7ffff000 (2,147,479,552) bytes, returning the number of bytes actually transferred. (This is true on both 32-bit and 64-bit systems.)
An error return value while performing write() using direct I/O does not mean the entire write has failed. Partial data may be written and the data at the file offset on which the write() was attempted should be considered inconsistent.
Among the APIs subsequently listed are write() and writev(2). And among the effects that should be atomic across threads (and processes) are updates of the file offset. However, on Linux before version 3.14, this was not the case: if two processes that share an open file description (see open(2)) perform a write() (or writev(2)) at the same time, then the I/O operations were not atomic with respect updating the file offset, with the result that the blocks of data output by the two processes might (incorrectly) overlap. This problem was fixed in Linux 3.14.
| 2019-10-10 | Linux |


HTML
HTML is the standard markup language for Web pages.
With HTML you can create your own Website.
HTML is easy to learn - You will enjoy it!
CSS
CSS is the language we use to style an HTML document.
CSS describes how HTML elements should be displayed.
This tutorial will teach you CSS from basic to advanced.
Bootstrap
Bootstrap 4 is the newest version of Bootstrap, which is the most popular HTML, CSS, and JavaScript framework for developing responsive, mobile-first websites.
Bootstrap 4 is completely free to download and use!
JavaScript
JavaScript is the world's most popular programming language.
JavaScript is the programming language of the Web.
JavaScript is easy to learn.
This tutorial will teach you JavaScript from basic to advanced.
jQuery
jQuery is a JavaScript Library.
jQuery greatly simplifies JavaScript programming.
jQuery is easy to learn.
Git and Github
Git is a distributed version-control system for tracking changes in any set of files, originally designed for coordinating work among programmers cooperating on source code during software development.
Its goals include speed, data integrity, and support for distributed, non-linear workflows.
GitHub, Inc. is a subsidiary of Microsoft which provides hosting for software development and version control using Git.


Keystroke Dynamics for
Usable Passwords
There is a fundamental conflict in creating what we’d like to call a bullseye password: one’s that is both user-friendly and secure.
This fundamental conflict led our research group to the question of, ‘what can we create that makes passwords more secure while not jeopardizing user-friendliness?’
For greater security, we knew that we wanted to use second factor authentication.
An example of a biometric password used for second factor authentication is keystroke dynamics.
There is a fundamental conflict in creating what we’d like to call a bullseye password: one’s that is both user-friendly and secure.
This fundamental conflict led our research group to the question of, ‘what can we create that makes passwords more secure while not jeopardizing user-friendliness?’
For greater security, we knew that we wanted to use second factor authentication.
An example of a biometric password used for second factor authentication is keystroke dynamics.
-->
Our Code
Our Presentation


×
home
account
login
about pulse
our team
☰
sign in
×
email address
password
account overview
My Account
Email
First Name
Last Name