STEP 0 - A note about access and permissions
To get access to bCourses, you will need a valid CalNet ID, and to create a course site, you will need to be the official instructor of record for a course. If you are a GSI for a course, you will not be able to create a site, unless its for the discussion section(s) that you are officially teaching.
STEP 1 - Log into bCourses
URL: https://bcourses.berkeley.edu
STEP 2 - Create your site
See this bCourses help article for step-by-step instructions: Create your course site
STEP 3 - Add your course materials
Adding your syllabus - You can upload an existing file or copy and paste your syllabus contents into the Syllabus tool.
Files - This is a repository for the files that you upload into bCourses. You can upload files directly here, or, you can upload them in other places in bCourses, such as anywhere there is an HTML editor, or in Modules. Please note: This tool has limited options for organizing content, and you cannot add links to external websites.
Modules - This is a tool where you can add not just files, but links to websites and other course content like Assignments (which include Assignments, Discussions, and Quizzes), Pages, etc. Any files that you upload into Modules also get automatically saved in Files. You can move content more freely and add virtually any type of content that you would like.
Pages - You can use pages to add text, media, links to files, course content, and websites. Pages can also be used as wikis, a space that both students and instructors can edit and use for document collaboration. Canvas keeps the entire history of the page so you can see how it changes over time.
STEP 4 - Add people
Students - Course sites are tied to official registration information (by CCN), so students who have registered for the course will automatically get access- no need to add them manually. Enrollment information is updated every morning between 6-8a, after this window, they will get access upon the next update.
Others - If would like to add unofficial TAs, class auditors, or other people into your course, they must have valid CalNet IDs.
- For guests who do not have a CalNet ID, see this bCourses help article: Sponsor a CalNet Guest Collaboration Account
- For those who already have valid CalNet IDs see this bCourses help article: Adding people to your site
STEP 5 - Publish your site
Now that you have created your site, added your course materials and other people, the last thing to do is publish it so that it is available for students to access. See this bCourses help article on publishing your site (its really easy!): Publish your site
STEP 6 - Student View
Want to see how your site looks to students before making it available to them? See this Canvas Guide: How do I access Student View?
For more information about bcourses site set up, please reference : https://www.ets.berkeley.edu/discover-services/bcourses/instructors-getting-started


3D-Globe
ANAND PRABHAKAR
Gallery
Blogger
Wordpress
About me
My personal site
see earth's 3DGLOBE
@AP


Ezekiel 12:18
Son of man, eat thy bread with quaking, and drink thy water with trembling and with carefulness;


--- layout: post title: Font Conference date: '2008-07-23T07:23:48+01:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/43219794/font-conference --- Font Conference


{% extends "site_base.html" %} {% load i18n %} {% load svn_app_version %} {% block head_title %}{% trans "Apps" %}{% endblock %} {% block tab_id %}id="apps_tab"{% endblock %} {% block body %}
{% trans "More about the apps that make up Pinax." %}
{% trans "These already exist as independent apps. Some pre-existed Pinax, some were written especially for it." %}
{% blocktrans %}django-openid is also used but locally for modification.{% endblocktrans %}
{% trans "These are currently inside Pinax but could potentially be broken out as generic apps." %}


Here is the content for the about us tab.
Here is the content for the about our culture tab.
Here is the content for the about our vision tab.


Near by Hospital Names
{%for i in range(0, length)%}
{{i+1}}.{{names[i]}}
({{address[i]}})
{%endfor%}


Electrical and Electronics Engineering and Computer Engineering student at Kadir Has University.
Product Development Engineer at PROFEN.
I started learning to code at high school. Over time, I improved myself and gained experience. Now I am developing my web development skills. I have developed backend for IoT systems at my experience on PROFEN.
I have learned how to brew beer during the global pandemic. With many practices and good results, I may call myself a master of beer.


This file contains device abstraction layer APIs for the PRU Subsystem. There are APIs here to enable/disable the
#include <stdint.h>
#include <string.h>
#include <ti/drv/pruss/pruicss.h>
#include <ti/drv/pruss/soc/pruicss_v1.h>
#include <ti/drv/pruss/src/pruicss_osal.h>
#include <ti/csl/cslr.h>
#include <ti/csl/src/ip/icss/V1/cslr_icss_pru_ctrl.h>
#include <ti/csl/src/ip/icss/V1/cslr_icss_intc.h>
#include <ti/csl/src/ip/icss/V1/cslr_icss_cfg.h>
#include <ti/csl/hw_types.h>
#include <ti/osal/SemaphoreP.h>
Functions | |
| PRUICSS_Handle | PRUICSS_create (PRUICSS_Config *config, int32_t instance) |
| This function creates the handle for the PRUICSS instance . More... | |
| int32_t | PRUICSS_setPRUBuffer (PRUICSS_Handle handle, uint32_t pruNum, void *buffer, uint32_t numBytes) |
| This function sets the buffer pointer for PRU. The contents of this buffer will be loaded to IRAM. . More... | |
| int32_t | PRUICSS_pruReset (PRUICSS_Handle handle, uint8_t pruNum) |
| Resets PRU: . More... | |
| int32_t | PRUICSS_pruDisable (PRUICSS_Handle handle, uint8_t pruNum) |
| Disables PRU: . More... | |
| int32_t | PRUICSS_pruEnable (PRUICSS_Handle handle, uint8_t pruNum) |
| Enables PRU: . More... | |
| int32_t | PRUICSS_pruCounterEnable (PRUICSS_Handle handle, uint8_t pruNum) |
| Enables PRU Cycle Counter: . More... | |
| int32_t | PRUICSS_pruWriteMemory (PRUICSS_Handle handle, uint32_t pruMem, uint32_t wordoffset, const uint32_t *source_mem, uint32_t bytelength) |
| This function writes the given data to PRU memory. More... | |
| int32_t | PRUICSS_pruInitMemory (PRUICSS_Handle handle, uint32_t pruMem) |
| This function intialize the PRU memory to zero. More... | |
| int32_t | PRUICSS_pruReadMemory (PRUICSS_Handle handle, uint32_t pruMem, uint32_t wordoffset, uint32_t *dest_mem, uint32_t bytelength) |
| This function reads from PRU memory and stores in block of memory. More... | |
| int32_t | PRUICSS_pruSendEvent (PRUICSS_Handle handle, uint32_t eventnum) |
| This function Generates an INTC event . More... | |
| int32_t | PRUICSS_pruClearEvent (PRUICSS_Handle handle, uint32_t eventnum) |
| This function clears an INTC event . More... | |
| int32_t | PRUICSS_pruWaitEvent (PRUICSS_Handle handle, uint32_t pruEvtoutNum) |
| This function waits for a Syatem event to happen . More... | |
| int32_t | PRUICSS_mapPruMem (PRUICSS_Handle handle, uint32_t pru_ram_id, void **address) |
| This function returns the address of PRU components. More... | |
| int32_t | PRUICSS_mapPeripheralIO (PRUICSS_Handle handle, uint32_t per_id, void **address) |
| This function returns the base address of peripheral IO modules. More... | |
| uint32_t | PRUICSS_detectHWVersion (void) |
| Detects the Chip Type . More... | |
| uint32_t | PRUICSS_getICSSVersion (PRUICSS_Handle handle) |
| Get PRU ICSS version : . More... | |
| int32_t | PRUICSS_pruExecProgram (PRUICSS_Handle handle, int32_t pruNum) |
| This function Executes the program in the specified PRU . More... | |
| int32_t | PRUICSS_pruSendWaitCearEvent (PRUICSS_Handle handle, uint32_t sendEventNum, uint32_t pruEvtoutNum, uint32_t ackEventNum) |
| This function generates and INTC event, waits for AINTC event and clears an INTC event . More... | |
| void | PRUICSS_pinMuxConfig (PRUICSS_Handle handle, uint64_t regVal) |
| Configure PIN_MUX_SEL. More... | |
| int32_t | PRUICSS_socGetInitCfg (PRUICSS_Config **cfg) |
| This API gets the SoC level of PRUICSS intial configuration. More... | |
| int32_t | PRUICSS_socSetInitCfg (PRUICSS_Config const *cfg) |
| This API sets the SoC level of PRUICSS intial configuration. More... | |
| int32_t | PRUICSS_setConstantTblEntry (PRUICSS_Handle handle, uint8_t pruNum, int32_t constantTblEntry, uint32_t constantTblVal) |
| This API updates the constant table for specified constant table entry which have write permissions. More... | |
| int32_t | PRUICSS_setGpMuxSel (PRUICSS_Handle handle, uint8_t pruNum, uint32_t mode) |
| This API configures the General Purpose Mux Selector field of the General Purpose Config Register (PRUSS_GPCFG) More... | |
| int32_t | PRUICSS_setIepClkSrc (PRUICSS_Handle handle, uint32_t source) |
| This API configures the source of the IEP clock to be either IEP CLK as the source or Interface Bus CLK as the source (such as OCP/ICLK/VCLK) This is accomplished by updating the IEP clock field of the General Purpose Config Register (PRUSS_GPCFG) More... | |
This file contains device abstraction layer APIs for the PRU Subsystem. There are APIs here to enable/disable the
============================================================================
| PRUICSS_Handle PRUICSS_create | ( | PRUICSS_Config * | config, |
| int32_t | instance | ||
| ) |
This function creates the handle for the PRUICSS instance
.
| config | configuration structure of PRUICSS. |
| instance | PRUICSS instance no. |
| uint32_t PRUICSS_detectHWVersion | ( | void | ) |
Detects the Chip Type
.
| uint32_t PRUICSS_getICSSVersion | ( | PRUICSS_Handle | handle | ) |
Get PRU ICSS version :
.
Get PRU ICSS version
.
| handle | Pruss's driver handle |
| int32_t PRUICSS_mapPeripheralIO | ( | PRUICSS_Handle | handle, |
| uint32_t | per_id, | ||
| void ** | address | ||
| ) |
This function returns the base address of peripheral IO modules.
| handle | Pruss's driver handle |
| per_id | Peripheral Module's Id. |
| address | Memory to which address to be copied. |
| int32_t PRUICSS_mapPruMem | ( | PRUICSS_Handle | handle, |
| uint32_t | pru_ram_id, | ||
| void ** | address | ||
| ) |
This function returns the address of PRU components.
| handle | Pruss's driver handle |
| pru_ram_id | PRU components' Id. |
| address | Memory to which address to be copied. |
| void PRUICSS_pinMuxConfig | ( | PRUICSS_Handle | handle, |
| uint64_t | regVal | ||
| ) |
Configure PIN_MUX_SEL.
| handle | Pruss's driver handle |
| regVal | value to be written |
| int32_t PRUICSS_pruClearEvent | ( | PRUICSS_Handle | handle, |
| uint32_t | eventnum | ||
| ) |
This function clears an INTC event
.
his function clears an INTC event
| handle | Pruss's driver handle |
| eventnum | The INTC Event number. |
| int32_t PRUICSS_pruCounterEnable | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum | ||
| ) |
Enables PRU Cycle Counter:
.
| handle | Pruss's driver handle |
| pruNum | PRU instance number[0 or 1]. |
| int32_t PRUICSS_pruDisable | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum | ||
| ) |
Disables PRU:
.
| handle | Pruss's driver handle |
| pruNum | PRU instance number[0 or 1]. |
| int32_t PRUICSS_pruEnable | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum | ||
| ) |
Enables PRU:
.
| handle | Pruss's driver handle |
| pruNum | PRU instance number[0 or 1]. |
| int32_t PRUICSS_pruExecProgram | ( | PRUICSS_Handle | handle, |
| int32_t | pruNum | ||
| ) |
This function Executes the program in the specified PRU
.
| handle | Pruss's driver handle |
| pruNum | PRU instance number. |
| int32_t PRUICSS_pruInitMemory | ( | PRUICSS_Handle | handle, |
| uint32_t | pruMem | ||
| ) |
This function intialize the PRU memory to zero.
This function initializes the PRU memory to zero.
| handle | Pruss's driver handle |
| pruMem | PRU Memory Macro |
pruMem can have the following values PRU_ICSS_SHARED_RAM
PRU_ICSS_DATARAM(n) where n is the PRU number
PRU_ICSS_IRAM(n) where n = 0 for PRU0,n = 1 for PRU1, n = 2 for RTU0, n = 3 for RTU1, maintaing this for backward compabitility , should use macros below
PRU_ICSS_IRAM_PRU(n) where n = 0 for PRU0,n = 1 for PRU1
PRU_ICSS_IRAM_RTU(n) where n = 0 for RTU0,n = 1 for RTU1
PRU_ICSS_IRAM_TXPRU(n) where n = 0 for TXPRU0,n = 1 for TXPRU1
| int32_t PRUICSS_pruReadMemory | ( | PRUICSS_Handle | handle, |
| uint32_t | pruMem, | ||
| uint32_t | wordoffset, | ||
| uint32_t * | dest_mem, | ||
| uint32_t | bytelength | ||
| ) |
This function reads from PRU memory and stores in block of memory.
| handle | Pruss's driver handle |
| pruMem | PRU Memory Macro |
| wordoffset | Offset at which the read will happen. |
| dest_mem | Destination memory[ Array of uint32_tegers ] |
| bytelength | Total number of bytes to be read |
pruMem can have the following values PRU_ICSS_SHARED_RAM
PRU_ICSS_DATARAM(n) where n is the PRU number
PRU_ICSS_IRAM(n) where n = 0 for PRU0,n = 1 for PRU1, n = 2 for RTU0, n = 3 for RTU1, maintaing this for backward compabitility , should use macros below
PRU_ICSS_IRAM_PRU(n) where n = 0 for PRU0,n = 1 for PRU1
PRU_ICSS_IRAM_RTU(n) where n = 0 for RTU0,n = 1 for RTU1
PRU_ICSS_IRAM_TXPRU(n) where n = 0 for TXPRU0,n = 1 for TXPRU1
| int32_t PRUICSS_pruReset | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum | ||
| ) |
Resets PRU:
.
| handle | Pruss's driver handle |
| pruNum | PRU instance number[0 or 1]. |
| int32_t PRUICSS_pruSendEvent | ( | PRUICSS_Handle | handle, |
| uint32_t | eventnum | ||
| ) |
This function Generates an INTC event
.
| handle | Pruss's driver handle |
| eventnum | The INTC Event number. |
| int32_t PRUICSS_pruSendWaitCearEvent | ( | PRUICSS_Handle | handle, |
| uint32_t | sendEventNum, | ||
| uint32_t | pruEvtoutNum, | ||
| uint32_t | ackEventNum | ||
| ) |
This function generates and INTC event, waits for AINTC event and clears an INTC event
.
| handle | Pruss's driver handle |
| sendEventNum | Event number. |
| pruEvtoutNum | PRU Event number. |
| ackEventNum | Acknowlodegement event number. |
| int32_t PRUICSS_pruWaitEvent | ( | PRUICSS_Handle | handle, |
| uint32_t | pruEvtoutNum | ||
| ) |
This function waits for a Syatem event to happen
.
This function waits for a System event to happen
.
| handle | Pruss's driver handle |
| pruEvtoutNum | The AINTC Event number. |
| int32_t PRUICSS_pruWriteMemory | ( | PRUICSS_Handle | handle, |
| uint32_t | pruMem, | ||
| uint32_t | wordoffset, | ||
| const uint32_t * | source_mem, | ||
| uint32_t | bytelength | ||
| ) |
This function writes the given data to PRU memory.
| handle | Pruss's driver handle |
| pruMem | PRU Memory Macro |
| wordoffset | Offset at which the write will happen. |
| source_mem | Source memory[ Array of uint32_tegers ] |
| bytelength | Total number of bytes to be writen |
pruMem can have the following values PRU_ICSS_SHARED_RAM
PRU_ICSS_DATARAM(n) where n is the PRU number
PRU_ICSS_IRAM(n) where n = 0 for PRU0,n = 1 for PRU1, n = 2 for RTU0, n = 3 for RTU1, maintaing this for backward compabitility , should use macros below
PRU_ICSS_IRAM_PRU(n) where n = 0 for PRU0,n = 1 for PRU1
PRU_ICSS_IRAM_RTU(n) where n = 0 for RTU0,n = 1 for RTU1
PRU_ICSS_IRAM_TXPRU(n) where n = 0 for TXPRU0,n = 1 for TXPRU1
| int32_t PRUICSS_setConstantTblEntry | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum, | ||
| int32_t | constantTblEntry, | ||
| uint32_t | constantTblVal | ||
| ) |
This API updates the constant table for specified constant table entry which have write permissions.
| handle | Pruss's driver handle |
| pruNum | PRU number[0 or 1] for which constant table is being updated. |
| constantTblEntry | contant table entry being updated |
| constantTblVal | contant table value to be written |
| int32_t PRUICSS_setGpMuxSel | ( | PRUICSS_Handle | handle, |
| uint8_t | pruNum, | ||
| uint32_t | mode | ||
| ) |
This API configures the General Purpose Mux Selector field of the General Purpose Config Register (PRUSS_GPCFG)
| handle | Pruss's driver handle |
| pruNum | PRU number[0 or 1]. |
| mode | PRU-ICSS wrap mux selection |
| int32_t PRUICSS_setIepClkSrc | ( | PRUICSS_Handle | handle, |
| uint32_t | source | ||
| ) |
This API configures the source of the IEP clock to be either IEP CLK as the source or Interface Bus CLK as the source (such as OCP/ICLK/VCLK) This is accomplished by updating the IEP clock field of the General Purpose Config Register (PRUSS_GPCFG)
| handle | Pruss's driver handle |
| source | source of the IEP clock (0 == IEP CLK, 1 == OCP/ICLK/VCLK) |
| int32_t PRUICSS_setPRUBuffer | ( | PRUICSS_Handle | handle, |
| uint32_t | pruNum, | ||
| void * | buffer, | ||
| uint32_t | numBytes | ||
| ) |
This function sets the buffer pointer for PRU. The contents of this buffer will be
loaded to IRAM.
.
| handle | Pruss's driver handle |
| pruNum | The PRU number. |
| buffer | Pointer to buffer. |
| numBytes | Number of bytes in the buffer. |
| int32_t PRUICSS_socGetInitCfg | ( | PRUICSS_Config ** | cfg | ) |
This API gets the SoC level of PRUICSS intial configuration.
| cfg | Pointer to PRUICSS SOC initial config. |
| int32_t PRUICSS_socSetInitCfg | ( | PRUICSS_Config const * | cfg | ) |
This API sets the SoC level of PRUICSS intial configuration.
| cfg | Pointer to PRUICSS SOC initial config. |


Shared Worker
Windows
new window(s).
Performance Test
Send a bytes payload
times to all connected windows.
Do the test time(s), and calculate the average duration.
Perform the test for the currently open windows.
Perform the test for 2 through windows.
Perform the test for 2 through windows.


jQuery CDN – Latest Stable Versions
jQuery Core
Showing the latest stable release in each major branch. See all versions of jQuery Core.
jQuery 3.x
- jQuery Core 3.2.1 - uncompressed, minified, slim, slim minified
jQuery 2.x
- jQuery Core 2.2.4 - uncompressed, minified
jQuery 1.x
- jQuery Core 1.12.4 - uncompressed, minified
jQuery Migrate
- jQuery Migrate 3.0.0 - uncompressed, minified
jQuery UI
Showing the latest stable release for the current and legacy release families. See all versions of jQuery UI.
jQuery UI 1.12
- jQuery UI 1.12.1 - uncompressed, minified
- Themes: base black-tie blitzer cupertino dark-hive dot-luv eggplant excite-bike flick hot-sneaks humanity le-frog mint-choc overcast pepper-grinder redmond smoothness south-street start sunny swanky-purse trontastic ui-darkness ui-lightness vader
jQuery UI 1.11
- jQuery UI 1.11.4 - uncompressed, minified
- Themes: black-tie blitzer cupertino dark-hive dot-luv eggplant excite-bike flick hot-sneaks humanity le-frog mint-choc overcast pepper-grinder redmond smoothness south-street start sunny swanky-purse trontastic ui-darkness ui-lightness vader
jQuery Mobile
Showing the latest stable release for jQuery Mobile. See all versions of jQuery Mobile.
- jQuery Mobile 1.4.5 - uncompressed, minified, theme (structure only)
jQuery Color
Showing the latest stable release for jQuery Color. See all versions of jQuery Color.
- jQuery Color 2.1.2 - uncompressed, minified
- jQuery Color SVG Color Names 2.1.2 - uncompressed, minified
- jQuery Color With Names (last two together) 2.1.2 - uncompressed, minified
QUnit
Showing the latest stable release for QUnit. See all versions of QUnit.
- QUnit 2.4.0 - uncompressed, theme
PEP
Showing the latest stable release for PEP. See all versions of PEP.
- PEP 0.4.3 - uncompressed, minified


*<-- EMAIL HEADER HERE -->*
*<-- TABLES HERE -->*
Unsubscribe
Copyright © 2015, All rights reserved.


FIXML Tool
Converts Fixml message entered as single line into readable English
(Accepts TradeCaptRpt, AllocRpt, AllocInstrctnAlert).
Submit
Created by
Alek Shnayder
.
Github
project page.


I've got a list of things, I don't know how long the list is and I want to display them in a number of columns across the page. The layout should be repsonsive so to fit as many items into a row as possible.
The old solution to this was to use some kind of grid system and explictly state the width of every item at a varying range of breakpoints. This was annoying as you had to think about multiple viewports:
100% wide by default, then then 50% when the viewport is greater than 400px, then 33% when the viewport is greater than 600px, then 25% when the viewport is greater than 800px. And so upwards until you get sick of naming breakpoints
The new solution is to use CSS grid. Grid allows you to create a variable number of columns based on the minimum size of a single column. This scales without having to be explicit about every breakpoint:
An item must be at least 200px wide. Fit as many items in a row as you can. Much simpler as we no longer have to think about multiple viewport-based breakpoints.
As an aid to reusability you can define that minimum value as a CSS variable, which allows you to configure it within your HTML if you've got multiple listings whose minimum size should be different widths
PS no you can't do this with flexbox, as the final row's items would strech to fill the width of that row, meaning they end up being a different width to the items in the other rows.


BITUpdateManagerDelegate Protocol Reference
| Conforms to | NSObject |
| Declared in | BITUpdateManagerDelegate.h |
Overview
The BITUpdateManagerDelegate
formal protocol defines methods further configuring
the behaviour of BITUpdateManager
.
Instance Methods
didDisplayExpiryAlertForUpdateManager:
Invoked once a default expiry alert is shown
- (void)didDisplayExpiryAlertForUpdateManager:(BITUpdateManager *)updateManager
Parameters
- updateManager
The
BITUpdateManager
instance invoking this delegate
Discussion
Once expiry date is reached and the default blocking UI is shown, this delegate method is invoked to provide you the possibility to do any desired additional processing.
See Also
Declared In
BITUpdateManagerDelegate.h
shouldDisplayExpiryAlertForUpdateManager:
Return if expiry alert should be shown if date is reached
- (BOOL)shouldDisplayExpiryAlertForUpdateManager:(BITUpdateManager *)updateManager
Parameters
- updateManager
The
BITUpdateManager
instance invoking this delegate
Discussion
If you want to display your own user interface when the expiry date is reached, implement this method, present your user interface and return NO. In this case it is your responsibility to make the app unusable!
Note: This delegate will be invoked on startup and every time the app becomes active again!
When returning YES the default blocking UI will be shown.
When running the app from the App Store, this delegate is ignored.
See Also
Declared In
BITUpdateManagerDelegate.h
updateManagerShouldSendUsageData:
Return NO if usage data should not be send
- (BOOL)updateManagerShouldSendUsageData:(BITUpdateManager *)updateManager
Parameters
- updateManager
The
BITUpdateManager
instance invoking this delegate
Discussion
The update module send usage data by default, if the application is NOT running in an App Store version. Implement this delegate and return NO if you want to disable this.
If you intend to implement a user setting to let them enable or disable sending usage data, this delegate should be used to return that value.
Usage data contains the following information: - App Version - iOS Version - Device type - Language - Installation timestamp - Usage time
Warning: When setting this to NO
, you will NOT know if this user is actually testing!
Declared In
BITUpdateManagerDelegate.h
viewControllerForUpdateManager:
Provide a parent view controller for the update user interface (Deprecated: Please use BITHockeyManagerDelegate viewControllerForHockeyManager:componentManager:
instead)
- (UIViewController *)viewControllerForUpdateManager:(BITUpdateManager *)updateManager
Parameters
- updateManager
The
BITUpdateManager
instance invoking this delegate
Discussion
If you don’t have a rootViewController
set on your UIWindow
and the SDK cannot
automatically find the current top most UIViewController
, you can provide the
UIViewController
that should be used to present the update user interface modal.
Declared In
BITUpdateManagerDelegate.h


exam4-ops-online.Rmd
Can be less than, greater than, or equal to constraints.
Anything that limits the ability to produce (time most precious, always a less than or equal to constraint).
Questions to ask when building the Master Production Schedule for job shops. Can be visualized with a gantt chart.
Gantt charts can be drawn as a PERT diagram.
Un-leveled (infinite capacity system): means we are building a time budget with unlimited constraints - will be shown as 104%
Leveled (finite capacity) schedule:
Dr. Goldratt example for managing MPS
Link the rope to the bottle neck (drum) - never want the Hereby to be idle since it is the longest running process.
How to order the sequence for building the product to minimize delay.
Processing on time delivery:
Job due date - cumulative time to complete previous work
Flow time - Due date
Total Days Late = sum(days_late)
Better KPI is the percentage of jobs delivered on time.
Re-order the jobs using different strategies to improve the days late/ ratio of jobs completed on time.
Slack = Due Date - Process Time
Slack / Number of open Operations
(given number)
Algorithm - two steps (with a bottle neck) bottle neck controls the pace.
Sorting algo that orders the jobs by where they are located (work center one or work center two).
Some times jobs will have to wait in buffers if job center two is not ready for the part.
Three things that can happen with parts moving through a plant:
setup <- tibble::tibble(
# Time to set up the machine
service_set_up_time = c(40, 28, 17, 44), # Minutes
# The scrap that results from processing (not all parts pass inspection)
percent_scrap = c(1, 2.5, 1.5, 3),
# Operation time/ unit (how long the process takes)
operation_time_unit = c(2.41, 6.20, .76, 1.37),
# Operator lost time due to breaks etc.
operator_lost_time = c(.5, .5, .6, .4) # Hours
)
# *Scrap Factor Analysis*
# 2000 is the number of finished goods we want - start in reverse order.
scrap_4 = 2000 / (1 - .03)
scrap_3 = scrap_4 / (1 - .015)
scrap_2 = scrap_3 / (1 - .025)
scrap_1 = scrap_2 / (1 - .01)
# We need to start at least 2169 products in order to produce 2,000 finished
# goods. Don't forget to round up! Would rather have to many than not enough.
# *Operating Time Analysis*
# Operation 1: 40 mins + .5 hours
# This is the time that no work is done: divide by 60 to get hours
operation_1 = (40/60) + .5 # Hours
operation_2 = (28/60) + .5 # Hours
operation_3 = (17/60) + .6 # Hours
operation_4 = (44/60) + .4 # Hours
# This is the time available after set up time and breaks are subtracted
# Work is done in 8 hour shifts.
op1 = 8 - operation_1
op2 = 8 - operation_2
op3 = 8 - operation_3
op4 = 8 - operation_4
# There is 6.87 hours to complete operation 4
Problem: Putting it all together.
answer <- tibble::tibble(
# Operation
operation = c(1, 2, 3, 4),
# time to complete a unit
minutes_per_unit = setup$operation_time_unit,
# minimum units to start
quantity_required = c(scrap_1, scrap_2, scrap_3, scrap_4),
# Total minutes
total_minutes_required = minutes_per_unit * quantity_required,
# Convert to hours
total_hours_required = total_minutes_required / 60,
# Amount of time available after breaks and setup time
operating_hours_per_day = c(op1, op2, op3, op4),
# Total days to complete 2000 units
total_days = total_hours_required / operating_hours_per_day,
# 8 Hours in a working day - Since my final number is recorded in days (total
# hours required / operating hours in a day), multiply by the number of working
# hours in the day to get the final answer.
total_hours = total_days * 8
)
answer %>%
knitr::kable(digits = 2, format.args = list(big.mark = ','))
| operation | minutes_per_unit | quantity_required | total_minutes_required | total_hours_required | operating_hours_per_day | total_days | total_hours |
|---|---|---|---|---|---|---|---|
| 1 | 2.41 | 2,168.61 | 5,226.36 | 87.11 | 6.83 | 12.75 | 101.98 |
| 2 | 6.20 | 2,146.93 | 13,310.95 | 221.85 | 7.03 | 31.54 | 252.34 |
| 3 | 0.76 | 2,093.25 | 1,590.87 | 26.51 | 7.12 | 3.73 | 29.81 |
| 4 | 1.37 | 2,061.86 | 2,824.74 | 47.08 | 6.87 | 6.86 | 54.85 |
Add back the amount of time it takes to transfer goods between operations.
# We have four hours between each operation: 3 delays at 4 hours
# 4 * 3 = 12
sum(answer$total_hours) + 12
#> [1] 450.973
Calculating whats available and what’s available to promise.
Continue to carry the available into the subsequent weeks.
Initial Value (starting inventory) +
Available = MPS scheduled receipts (orders/goods received ) -
Larger of Forecast or Orders
Available = 5 (starting value) + 50 (MPS) - 20 (Forecast)
Available = 35
Available To Promise = MPS - Total Actual Orders up to the next MPS
Available To Promise = 50 - 12 (orders week 1) - 6 (orders week 2)
Available To Promise = 32
JIT is the way we run organizations today
If there are items that meet these considerations than Economic order Quantity, and Reorder point may be valid methods for managing inventory.
Resembles a saw tooth - meets the assumptions defined above.
Total Cost = Order cost + Carry cost
Carry cost: goal is maximize the benefit of getting the best price while managing the costs associated with received larger orders. (balance bulk pricing with carry costs).
Goal is minimize the total costs = order cost + carry cost
EOQ: Minimum cost is the intersection of order cost and carry cost
# Average inventory cost
annual_useage = 24000
product_cost = 10
# Orders per year
order_annual = 6
# Units per order per year
units_per_order = annual_useage / order_annual
# Calculate the average amount of inventory on hand to determine
# the average cost of inventory
max_inventory = 4000
min_inventory = 0
# Average inventory on hand
avg_inventory = (max_inventory + min_inventory) / 2
# Average dollar investment for inventory
avg_inventory * product_cost
#> [1] 20000
Economic order quantity is the point that minimizes the carry cost and order cost. It is the number (quantity) of products to order.
EOQ = sqrt((2 * OC * AU) / (P * CC))
At EOQ, order cost and carry cost will be equal (rounding might change result).
# Total annual order cost = (AU / EOQ) * OC
# Quantity
annual_useage = 15000
EOQ = 600
# Order cost per unit (given)
order_cost = 15
# Number of orders per year
annual_useage / EOQ
#> [1] 25
# Total annual order cost: cost to place all orders for the year
total_annual_order = (annual_useage / EOQ) * order_cost
# Total annual carry cost = ((EOQ * Price) /2) * Carry Cost
# Dollars
price = 5
# Percent 25%
carry_cost = .25
# Total annual carry cost - divide by 2 to get average dollar investment
total_annual_order_cost = ((EOQ * price ) / 2) * .25
# Answer
TotalCost = total_annual_order + total_annual_order_cost
What happens when we order some quantity other than EOQ?
Should we pass on the discount or take it? Will the discount increase are carry costs greater than the amount of the discount?
order_cost = 15
carry_cost_pct = .3
annual_useage = 36000
# Price is we order 6,000 or more units (volume discount)
price_disc = 9.8
price = 10
# Quantity to order
EOQ = 600
discount_quantity = 6000
# Product A - No discount - EOQ
material = annual_useage * price
order_cost = (annual_useage / EOQ) * 15
orders_per_year = annual_useage / EOQ
carry_cost = ((EOQ * price) / 2 ) * carry_cost_pct
total_a = sum(material, order_cost, carry_cost)
# Product B - Discount - Discount Quantity
material = annual_useage * price_disc
# Order cost will decrease because of the discount
order_cost = (annual_useage / discount_quantity) * 15
orders_per_year = annual_useage / discount_quantity
carry_cost = ((discount_quantity * price_disc) / 2 ) * carry_cost_pct
total_b = sum(material, order_cost, carry_cost)
# We should take the discount - savings of $90.
waldo::compare(total_a, total_b)
#> `old`: 361800
#> `new`: 361710
The average dollar investment for EOQ will be smaller than the average dollar investment for bulk purchases (saw tooth graph on top of discount chart with much lower inventory turn).
ROI = Savings (from taking discount) / Investment (outlay for product purchase)
savings = 90
# Dollars spent to make purchase at discount price
discount_average_investment = discount_quantity * price_disc / 2
eoq_average_investment = EOQ * price / 2
# Bulk purchasing requires greater up front capital expenditure: calculate ROI
# on the incremental dollars required to hold the inventory.
extra_investment_required = discount_average_investment - eoq_average_investment
# ROI is calculated as the savings / the additional capital requirement for
# making the bulk purchase
ROI = scales::percent(savings / extra_investment_required, accuracy = .01)
This ROI calculation is the opportunity cost of giving up $26,400 to bulk purchase the inventory.
We can ask the vendor to modify the minimum purchase order for the discount in order to reduce the carry cost (greater number of orders in the year) to boost the ROI.
The point at which we need to order new product so we don’t stock out.
# Total cost of the order - includes shipping, tariffs, etc.
order_cost = 12
# 20%
carry_cost = .2
annual_useage = 3000
price = 4
# Three weeks: Average lead time
lead_time = 3
# $20 stock out - opportunity cost: when you hit zero and cannot fill an order
# Do you lose the sale and future business.
stock_out_cost = 20
weeks_of_operation = 50
orders_per_year = 10
Distribution for product orders: shows the distribution for quantity demanded during average lead times.
# The reorder point will be somewhere greater than zero
# Step 1: The minimum quantity to keep on hand
# Average Lead Time Usage = (annual usage / weeks ) * average lead time
average_lead_time_usage = (annual_useage / weeks_of_operation) * lead_time
# Answer 180 units is the minimum number of units we should keep in stock.
# Safety Stock: is the difference in current stock and reorder point
# Stock on hand: 200
# Reorder point: 180
# Safety Stock: 20
data.frame(
q_demand = seq(100, 260, 20),
q_freq = c(4, 10, 18, 32, 70, 28, 20, 12, 6)
) %>%
ggplot(aes(q_demand, q_freq)) +
geom_col()
If we set the reorder point at 260 - the probability of a stock out is zero since we have never sold more than 260 units.
arrange(desc(order_point)) %>% cumsum(prob_q_demanded)
.
We have calculated that the reorder point is 180, but has a 33% chance of stock out according to historical data. We should set a higher reorder point to reduce the chance of stock out.
WE minimize the total cost = stock out cost + carry cost
# As we raise the reorder point, the stock out cost will be reduced.
stock_outt <- tibble(
reorder_point = seq(180, 260, 20),
probability_stock_out = c(.33, .19, .09, .03, .0),
stockoutcost = (orders_per_year * probability_stock_out) * stock_out_cost
)
stock_outt %>%
knitr::kable()
| reorder_point | probability_stock_out | stockoutcost |
|---|---|---|
| 180 | 0.33 | 66 |
| 200 | 0.19 | 38 |
| 220 | 0.09 | 18 |
| 240 | 0.03 | 6 |
| 260 | 0.00 | 0 |
# As inventory increases, so does the carry cost
carry_costt <- tibble(
reorder_point = seq(180, 260, 20),
# reorder point - average_lead_time_usage = safety stock level
carrycost = ((reorder_point - average_lead_time_usage) * price) * carry_cost
)
carry_costt %>%
knitr::kable()
| reorder_point | carrycost |
|---|---|
| 180 | 0 |
| 200 | 16 |
| 220 | 32 |
| 240 | 48 |
| 260 | 64 |
# Choose the lowest total cost that minimizes the carry cost / stock out cost
stock_outt %>%
left_join(carry_costt) %>%
mutate(totalcost = stockoutcost + carrycost) %>%
knitr::kable()
#> Joining, by = "reorder_point"
| reorder_point | probability_stock_out | stockoutcost | carrycost | totalcost |
|---|---|---|---|---|
| 180 | 0.33 | 66 | 0 | 66 |
| 200 | 0.19 | 38 | 16 | 54 |
| 220 | 0.09 | 18 | 32 | 50 |
| 240 | 0.03 | 6 | 48 | 54 |
| 260 | 0.00 | 0 | 64 | 64 |
Order cost == shipping: the extra cost associated with processing the order. - There is no carry cost if there is no inventory - If there is 0 units there is no stock out costs - If there is 0 units and we sell a unit there IS A stock out cost.
# Simulation problem: start with no open orders
# $1/ Unit / Week on the ending balance
order_cost = 10
# $3/ Unit/ Week
carry_cost = 1
stock_out_cost = 3
# Current stock Units
balance_on_hand = 12
# Reorder point
order_point = 7
# EOQ
order_quantity = 8
Lead time analysis - the lead time is not constant
# Simulate the various lead times
lead_times <- tibble(
lead_time = 1:5,
lead_frequency = c(2, 6, 11, 5, 1),
# probability the lead time will be 1 week or 5 weeks.
lead_probability = lead_frequency / sum(lead_frequency),
lead_cdf = cumsum(lead_probability)
)
lead_times %>%
ggplot(aes(lead_time, lead_cdf)) +
geom_line() +
scale_y_continuous(labels = scales::percent_format()) +
labs(title = '75% of all lead times were three weeks or less')
Demand analysis: Demand is not always constant
# Historical data
demand_analysis <- tibble(
# Units sold in a given week
demand_week = 0:6,
demand_frequency = c(1, 6, 9, 19, 8, 5, 2),
demand_probability = demand_frequency / sum(demand_frequency),
demand_cdf = cumsum(demand_probability)
)
demand_analysis %>%
ggplot(aes(demand_week, demand_cdf)) +
geom_line() +
scale_y_continuous(labels = scales::percent_format()) +
labs(title = 'Probability three or more units\nsold in a given week is <= 70%',
x = 'Quantity demanded / week', y = 'Probability')
Reorder point question
How many do we have on hand / on order
quantity on hand + quantity on order <= Reorder Point
SIMULATION EXPLANATION
# Order point is 7: the point at which we need to order new product
# Starting quantity on hand is 12.
# Week one we do not need to order.
tibble(
week = 1:10,
# Randomly chosen lead time 1:5 weeks
# LeadTimeRandom = hash function for choosing the lead time
# Randomly chosen demand 0:6 units / week
# DemandNumberRandom = hash function for choosing quantity demanded
QuantityDemanded = c(1, 3, 2, 4, 2, 1, 3, 3, 0, 4),
# Starting quantity of 12 - 1 = 11 for week one
QuantityOnHand = c(11, 8, 6, 2, 0, -1, 4, 1, 9, 5),
# Order when TotalQuantity <= 7
QuantityOrdered = c(0, 0, 0, 8, 0, 0, 8, 0, 0, 0),
# Lead time probability is used to determine how long the order is in transit
# Could be a value 1:6.
OnOrder = c(0, 0, 0, 0, 8, 8, 0, 8, 0, 0),
# Product is received two weeks later
QuantityReceived = c(0, 0, 0, 0, 0, 0, 8, 0, 8, 0),
TotalQuantity = QuantityOnHand + QuantityOrdered + OnOrder,
OrderCost = ifelse(QuantityOrdered > 0, 10, 0),
# Carry cost is $1/ unit on ending balance
CarryCost = ifelse(QuantityOnHand > 0, QuantityOnHand * carry_cost, 0),
StockOutCost = ifelse(QuantityOnHand < 0, 3, 0),
TotalCost = OrderCost + StockOutCost + CarryCost,
CumulativeCost = cumsum(TotalCost)
) %>%
knitr::kable()
| week | QuantityDemanded | QuantityOnHand | QuantityOrdered | OnOrder | QuantityReceived | TotalQuantity | OrderCost | CarryCost | StockOutCost | TotalCost | CumulativeCost |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 1 | 11 | 0 | 0 | 0 | 11 | 0 | 11 | 0 | 11 | 11 |
| 2 | 3 | 8 | 0 | 0 | 0 | 8 | 0 | 8 | 0 | 8 | 19 |
| 3 | 2 | 6 | 0 | 0 | 0 | 6 | 0 | 6 | 0 | 6 | 25 |
| 4 | 4 | 2 | 8 | 0 | 0 | 10 | 10 | 2 | 0 | 12 | 37 |
| 5 | 2 | 0 | 0 | 8 | 0 | 8 | 0 | 0 | 0 | 0 | 37 |
| 6 | 1 | -1 | 0 | 8 | 0 | 7 | 0 | 0 | 3 | 3 | 40 |
| 7 | 3 | 4 | 8 | 0 | 8 | 12 | 10 | 4 | 0 | 14 | 54 |
| 8 | 3 | 1 | 0 | 8 | 0 | 9 | 0 | 1 | 0 | 1 | 55 |
| 9 | 0 | 9 | 0 | 0 | 8 | 9 | 0 | 9 | 0 | 9 | 64 |
| 10 | 4 | 5 | 0 | 0 | 0 | 5 | 0 | 5 | 0 | 5 | 69 |
Purpose is to balance stock outs, reorder point, and carry costs to reduce the cumulative total cost of managing inventory.
End simulation
We can build to the forecast or to actual order: (right) side is the market
Parts and there respective lead times.
We order goods for when they are needed based on requirement for sub-assemblies and the lead time.
What is the projected available balance in week number 1?
# Batch Size when placing orders
q = 20
# Lead time
lead_time = 1
# Safety Stock
safety_stock = 0
# Starting balance
starting_balance = 21
# Work problem
tibble(
product = 'parta',
week = 1:6,
# Given part of the problem
gross_requirements = c(5, 15, 18, 8, 12, 22),
# Starting balance (21) - gross requirements
ProjectedAvailableBalance = c(16, 1, 3, 15, 3, 1),
# Need to cover the gross requirements for the subsequent week
PlannedOrder = c(0, 20, 20, 0, 20, 0),
# One week lead time stated in problem
ScheduledReceived = c(0, 0, 20, 20, 0, 20)
) %>%
knitr::kable()
| product | week | gross_requirements | ProjectedAvailableBalance | PlannedOrder | ScheduledReceived |
|---|---|---|---|---|---|
| parta | 1 | 5 | 16 | 0 | 0 |
| parta | 2 | 15 | 1 | 20 | 0 |
| parta | 3 | 18 | 3 | 20 | 20 |
| parta | 4 | 8 | 15 | 0 | 20 |
| parta | 5 | 12 | 3 | 20 | 0 |
| parta | 6 | 22 | 1 | 0 | 20 |
If we want to reduce the number of stock outs, we can increase the quantity ordered.
We calculate the gross requirements for sub-assembly b by looking at the planned orders for product a.
b requirements 20 (planned order a) * 2 (each a requires two b sub-assemblies)
# Batch size 40
q = 40
# Two week lead time
lead_time = 2
tibble(
product = 'partb',
week = 1:6,
# Calculated by looking at the Planned order field.
gross_requirements = c(0, 40, 40, 0, 40, 0),
# Starting balance (20) + scheduled to receive 32 in first week & 0 gross req.
ProjectedAvailableBalance = c(52, 12, 12, 12, 12, 12),
# Need to cover the gross requirements for the subsequent week
PlannedOrder = c(40, 0, 40, 0, 0, 0),
# Two week lead time stated in problem
ScheduledReceived = c(32, 0, 40, 0, 40, 0)
) %>%
knitr::kable()
| product | week | gross_requirements | ProjectedAvailableBalance | PlannedOrder | ScheduledReceived |
|---|---|---|---|---|---|
| partb | 1 | 0 | 52 | 40 | 32 |
| partb | 2 | 40 | 12 | 0 | 0 |
| partb | 3 | 40 | 12 | 40 | 40 |
| partb | 4 | 0 | 12 | 0 | 0 |
| partb | 5 | 40 | 12 | 0 | 40 |
| partb | 6 | 0 | 12 | 0 | 0 |
Part c: to get the gross requirements - multiply the planned order releases for part a and c by 1..
# Lot for lot: order what is required
q = 'LotForLot'
# One week lead time
lead_time = 1
# Maintain safety stock of 10: Add 10 to gross_requirements
a = c(0, 20, 20, 0, 20, 0)
b = c(40, 0, 40, 0, 0, 0)
c_gross_requirements = a + b
tibble(
product = 'partc',
week = 1:6,
# Calculated by looking at the Planned order field.
gross_requirements = c_gross_requirements, # 40, 20, 60, 0, 20, 0
# Starting balance (50) + scheduled to receive 32 in first week & 0 gross req.
ProjectedAvailableBalance = c(10, 10, 10, 10, 10, 10),
# Need to cover the gross requirements for the subsequent week
PlannedOrder = c(20, 60, 0, 20, 0, 0),
# Two week lead time stated in problem
ScheduledReceived = c(0, 20, 60, 0, 20, 0)
) %>%
knitr::kable()
| product | week | gross_requirements | ProjectedAvailableBalance | PlannedOrder | ScheduledReceived |
|---|---|---|---|---|---|
| partc | 1 | 40 | 10 | 20 | 0 |
| partc | 2 | 20 | 10 | 60 | 20 |
| partc | 3 | 60 | 10 | 0 | 60 |
| partc | 4 | 0 | 10 | 20 | 0 |
| partc | 5 | 20 | 10 | 0 | 20 |
| partc | 6 | 0 | 10 | 0 | 0 |
The gross requirements are given for product zero.
Alex: Main character Manager of Plant
Jonah: Professor
Throughput = Total Revenue - Raw Materials
Inventory
Operating Expense = All Costs Except Raw Materials
Drum - Buffer - Rope
To Make Money:
Look at the effect on
Think about how each process effects the other and look for the bottleneck (Herby).
The group as a whole will never move faster than the slowest component.
Inventory management
Manage orders
Output of the plant is limited to the bottleneck
Constraint moves to the market
Process of ongoing improvement


About me!
Hello there, and thanks for stopping by! My name is Brad Williams and I was born and raised right here in Atlanta, Ga. I graduated from high school in 2008, where I then went on to study Spanish at Auburn University. War Eagle! After graduation, I taught Spanish for 2 years in Atlanta, and then picked up my things and moved a few thousand miles south to Santiago, Chile! While in Chile, I taught English to both children and adults, improving both my Spanish language skills and broadening my cultural perspective. While it was at times jarring, I loved my time in Chile, the people I met and the experiences I gained while living there. After a year, I decided to head back to the U.S. where I would go on to work for Teach for America in Denver, Colorado. In Denver, I taught math in an English as a second language classroom to first generation hispanic immigrants.
In 2017, I decided that I no longer wanted to pursue a career in teaching, mainly because of the sheer lack of financial growth available for most long term teachers. I then moved back to Atlanta and began working at a coworking startup, SharedSpace, at the peak of the coworking bubble. I started as General Manager, and after bringing a space to profitability, I then went on to open two more spaces, one in Cobb County and another in Augusta, Ga. While working at SharedSpace, I hosted a coding bootcamp, which sparked an interest in coding that would stick with me until today. I worked for SharedSpace for 2 years. While opening the SharedSpace location in Augusta, I was approached about a position with a startup concept called Kefi, which I decided to follow, yet again bringing me back to Atlanta. At Kefi, I was very quickly promoted to manager, but as is the nature of startups, it came with its own set of challenges, and ended up not being the place for me. Once covid-19 hit the U.S., the signs were clear, and I decided to move on to bigger and better things.
I’m now working full time as a student at the Georgia Tech Coding bootcamp following my dream of becoming a developer. While not coding, I love to play video games, cook, watch movies, and spend time with my girlfriend and pets. I love learning foreign languages and I speak spanish at an advanced level, and I’m hoping to add a few coding languages to my belt as well!


DiscordEngine
open class DiscordEngine : DiscordEngineSpec
The base class for Discord WebSocket communications.
-
The url for the gateway.
Declaration
Swift
open var connectURL: String
-
The type of DiscordEngineSpec. Used to correctly fire events.
Declaration
Swift
open var description: String
-
Creates the handshake object that Discord expects. Override if you need to customize the handshake object.
Declaration
Swift
open var handshakeObject: [String: Any]
-
Creates the resume object that Discord expects. Override if you need to customize the resume object.
Declaration
Swift
open var resumeObject: [String: Any]
-
The dispatch queue that heartbeats are sent on.
Declaration
Swift
public let heartbeatQueue = DispatchQueue(label: "discordEngine.heartbeatQueue")
-
The total number of shards.
Declaration
Swift
public let numShards: Int
-
The shard number of this engine.
Declaration
Swift
public let shardNum: Int
-
The queue that WebSockets use to parse things.
Declaration
Swift
public let parseQueue = DispatchQueue(label: "discordEngine.parseQueue")
-
The UUID of this WebSocketable.
Declaration
Swift
public var connectUUID = UUID()
-
This engine’s session id.
Declaration
Swift
public var sessionId: String?
-
The underlying WebSocket.
On Linux this is a WebSockets.WebSocket. While on macOS/iOS this is a Starscream.WebSocket
Declaration
Swift
public var websocket: WebSocket?
-
Whether this engine is connected to the gateway.
Declaration
Swift
public internal(set) var connected = false
-
The interval (in seconds) to send heartbeats.
Declaration
Swift
public internal(set) var heartbeatInterval = 0
-
The delegate that this engine is associated with.
Declaration
Swift
public private(set) weak var delegate: DiscordShardDelegate?
-
The last sequence number received. Will be used for session resumes.
Declaration
Swift
public private(set) var lastSequenceNumber = -1
-
Creates a new DiscordEngine.
Declaration
Swift
public required init(delegate: DiscordShardDelegate, shardNum: Int = 0, numShards: Int = 1)
Parameters
delegate
The DiscordClientSpec this engine should be associated with.
-
Disconnects the engine. An
engine.disconnect
is fired on disconnection.Declaration
Swift
public func disconnect()
-
Handles a close from the WebSocket.
Declaration
Swift
open func handleClose(reason: Error? = nil)
Parameters
reason
The reason the socket closed.
-
Handles a dispatch payload.
Declaration
Swift
open func handleDispatch(_ payload: DiscordGatewayPayload)
Parameters
payload
The dispatch payload
-
Handles a DiscordGatewayPayload. You shouldn’t need to call this directly.
Override this method if you need to customize payload handling.
Declaration
Swift
open func handleGatewayPayload(_ payload: DiscordGatewayPayload)
Parameters
payload
The payload object
-
Handles the hello event.
Declaration
Swift
open func handleHello(_ payload: DiscordGatewayPayload)
Parameters
payload
The dispatch payload
-
Handles the resumed event. You shouldn’t call this directly.
Declaration
Swift
open func handleResumed(_ payload: DiscordGatewayPayload)
-
Parses a raw message from the WebSocket. This is the entry point for all Discord events. You shouldn’t call this directly.
Override this method if you need to customize parsing.
Declaration
Swift
open func parseGatewayMessage(_ string: String)
Parameters
string
The raw payload string
-
Tries to resume a disconnected gateway connection.
Declaration
Swift
open func resumeGateway()
-
Sends a heartbeat to Discord. You shouldn’t need to call this directly.
Override this method if you need to customize heartbeats.
Declaration
Swift
open func sendHeartbeat()
-
Starts the handshake with the Discord server. You shouldn’t need to call this directly.
Override this method if you need to customize the handshake process.
Declaration
Swift
open func startHandshake()
-
Starts the engine’s heartbeat. You should call this method when you know the interval that Discord expects.
Declaration
Swift
public func startHeartbeat(milliseconds: Int)
Parameters
milliseconds
The heartbeat interval


Football Game Arrives On Switch This Week, But Don't Expect To Play Much Football
Things aren't as they seem
by Ryan CraddockLaunching later this week on Nintendo Switch is Football Game, but despite what the title might suggest, you won't actually be playing much football.
Instead, this one is a point-and-click thriller inspired by the classics of the genre released back in the '80s and '90s. You'll be joining Tommy, a local high school football hero, as he wakes up before a big game. He had planned to meet up with his girlfriend before the match, but something isn't quite right.
You'll soon find yourself exploring the environment by interacting with objects and inspecting them to solve puzzles, all in the hope of finding Tommy's sweetheart.
Features:
- Traditional point and click adventure game aesthetic with puzzles and dialogue interactions
- Meet a cast of characters including friends, foes, teachers, and a concerned mother
- An award-winning OST by UK duo JUPITER-C
The game arrives on Switch this Friday, 8th November. You'll be able to pick it up from the eShop for $4.99 / 4.99€.
What do you think? Liking the sound of this one? Share your thoughts with us in the comments below.


[§482-54] Severability. If any provision of this chapter is deemed to be invalid, the remaining provisions of this chapter shall continue to be effective. [L 2008, c 108, pt of §1]


Creative Computing
Joel Gethin Lewis
Week 10: Lecture 17: Practice presentations and maths/coding catch-up
What I'm going to talk about now:
- Group meditation.
- Questions?
- Practice presentations.
- Maths/coding catch-up.
- Feedback.
Are you recording Joel? Have you taken the register first?
2. Practice presentations.
- Two minutes each, then feedback.
3. Maths/coding catch-up.
- What did we decide three weeks ago?
4. Feedback
- What's working?
- What's not working?
- What am I missing?
- Lets talk now or you can Slack me in private.


---
layout: post
title: 'LIFT 2008: Upgrade your company - Industrial opportunities for the internet of things'
date: 2008-02-06 00:00:00
categories: business digital-media interfaces-&-interaction mobile social
---
Upgrade your company - Industrial opportunities for the internet of things, Vlad Trifa
(I arrived 15 minutes later, after the presentation)
Growth in open source sensor technologies. SAPs NetWeaver is an open source set of tech for this. Interop is important - companies want open standards.
[ Break-out session on threats and opportunities of embedded sensor networks ]
Now classifying thinking from the various groups into technological, social, interaction design and business aspects: T, S, I, B
Group 1:
- Do we let computers decide? (S)
- Do I trust these systems? (S)
- How do we know we're safe from hackers either controlling or reading sensors? (T, S)
- How do we ensure data is encrypted or safe? Should it expire so that by the time it can be encrypted, it's worthless? (T)
- Is it healthy? (S)
- How do you route traffic in a large network? (T)
- Can we share network information freely and share it (e.g. Swiss train timetables and train positions)? (I)
- Can we create our own on-the-fly networks? (I)
- How do we present a "CPU-based-solution"? (T)
- What do we want? (B)
Group 2:
- Technology is neutral, use of technology is where opportunity/risk lies. (S)
- Lots of opportunities for company appliances. (S)
- How do we define access to data or limits of privacy? (S)
- What happens at the end of these devices' life? What's their life cycle and ecological impact? (S)
- Energy issues, energy scavenging from whatever you monitor (e.g. measure vibrations and simultaneously extract energy from them). (T)
- Challenge of integration: will human beings accept this sort of thing on a large scale? What happens to people who don't accept it? (S)
- Customers are looking for differentiation, but much of this technology is a commodity and everywhere - which doesn't bring that. (B)
- Legally and in terms of privacy, we're lagging behind the technology. (S)
- There's no standardisation of this stuff yet when it comes to RFID (and wireless or even power). (S)
- Singapore is interesting: they've integrated some of these technologies and can monitor a great deal about their citizens. (S)
- Maybe these technologies could be used for selective terrorism - e.g. use RFID readers to recognise individual Americans and therefore target individuals. (S)
Group 3:
- How do we design for failure, for networks of sensors which have a finite life and depend on each other? (T)
- The classic science-fiction vision of the future is seamless, with technology mediating everyday life. How might we use sensor networks to bring back serendipity? (S)
- Digital sensors digitise everything, quantising analogue data. Does access to digital sensors reduce our confidence in the analogue (biological) ones? (I)
- Measuring something changes our relationship to it - e.g. Nike+ changes my running habits. (I)
- Younger generations may have a different relationship with this technology to us. We consider our homes to be what lies within 4 walls, when wireless networks extend our reach beyond these confined areas - an extension younger generations may unconsciously factor in. (Channelling Dunne & Raby here) (S)
- Ethical debate: we embed chips into cats and dogs, when do we start routinely doing this to humans? (S)
- Visibility: the dilemma of control over being controlled. (S)
Vlad talks about a "city of the future" being funded and built from scratch in Korea, which will be fully digital: no money, keys, etc: "New Songdo City". Also brings up the example of Octopus in Korea (must find out more about this).
Question from the audience: is there another model of exchange beyond bits and bytes of privacy exchanged for a smoother passage through life?
(Would this data have value if anonymised and then aggregated? Would this provide a means of playing with these sort of networks (which we don't fully understand) in society (which we don't fully understand) more safely? So, for instance: the room I'm in right now has 14 or so people in it. The fact that there are 14 people here probably enables us to make some sensible decisions around air conditioning, temperature, and lighting - without us knowing anything about who these people are. So would a sensor network which only provides information consumers with anonymised information be of any value?)
Q: how do we cope with different desires from different individuals? If I walk into a room and tell the window to open, then my dad walks in and asks it to close - who wins? How do we achieve consensus with these technologies as we do in a democratic way in our society?


EVP_DigestVerifyInit_ex, EVP_DigestVerifyInit, EVP_DigestVerifyUpdate, EVP_DigestVerifyFinal, EVP_DigestVerify - EVP signature verification functions
#include <openssl/evp.h>
int EVP_DigestVerifyInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
const char *mdname, OSSL_LIB_CTX *libctx,
const char *props, EVP_PKEY *pkey,
const OSSL_PARAM params[]);
int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey);
int EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
size_t siglen);
int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sig,
size_t siglen, const unsigned char *tbs, size_t tbslen);
The EVP signature routines are a high-level interface to digital signatures. Input data is digested first before the signature verification takes place.
EVP_DigestVerifyInit_ex() sets up verification context ctx to use a digest with the name mdname and public key pkey. The name of the digest to be used is passed to the provider of the signature algorithm in use. How that provider interprets the digest name is provider specific. The provider may implement that digest directly itself or it may (optionally) choose to fetch it (which could result in a digest from a different provider being selected). If the provider supports fetching the digest then it may use the props argument for the properties to be used during the fetch. Finally, the passed parameters params, if not NULL, are set on the context before returning.
The pkey algorithm is used to fetch a EVP_SIGNATURE method implicitly, to be used for the actual signing. See "Implicit fetch" in provider(7) for more information about implicit fetches.
The OpenSSL default and legacy providers support fetching digests and can fetch those digests from any available provider. The OpenSSL FIPS provider also supports fetching digests but will only fetch digests that are themselves implemented inside the FIPS provider.
ctx must be created with EVP_MD_CTX_new() before calling this function. If pctx is not NULL, the EVP_PKEY_CTX of the verification operation will be written to *pctx: this can be used to set alternative verification options. Note that any existing value in *pctx is overwritten. The EVP_PKEY_CTX value returned must not be freed directly by the application if ctx is not assigned an EVP_PKEY_CTX value before being passed to EVP_DigestVerifyInit_ex() (which means the EVP_PKEY_CTX is created inside EVP_DigestVerifyInit_ex() and it will be freed automatically when the EVP_MD_CTX is freed). If the EVP_PKEY_CTX to be used is created by EVP_DigestVerifyInit_ex then it will use the OSSL_LIB_CTX specified in libctx and the property query string specified in props.
No EVP_PKEY_CTX will be created by EVP_DigestVerifyInit_ex() if the passed ctx has already been assigned one via EVP_MD_CTX_set_pkey_ctx(3). See also SM2(7).
Not all digests can be used for all key types. The following combinations apply.
Supports SHA1, SHA224, SHA256, SHA384 and SHA512
Supports SHA1, SHA224, SHA256, SHA384, SHA512 and SM3
Supports no digests (the digest type must be NULL)
Supports SHA1, SHA256, SHA384 and SHA512
Support SHA1, SHA224, SHA256, SHA384, SHA512, MD5, MD5_SHA1, MD2, MD4, MDC2, SHA3-224, SHA3-256, SHA3-384, SHA3-512
Support no digests (the digest type must be NULL)
Supports any digest
Will ignore any digest provided.
If RSA-PSS is used and restrictions apply then the digest must match.
EVP_DigestVerifyInit() works in the same way as EVP_DigestVerifyInit_ex() except that the mdname parameter will be inferred from the supplied digest type, and props will be NULL. Where supplied the ENGINE e will be used for the signature verification and digest algorithm implementations. e may be NULL.
EVP_DigestVerifyUpdate() hashes cnt bytes of data at d into the verification context ctx. This function can be called several times on the same ctx to include additional data.
EVP_DigestVerifyFinal() verifies the data in ctx against the signature in sig of length siglen.
EVP_DigestVerify() verifies tbslen bytes at tbs against the signature in sig of length siglen.
EVP_DigestVerifyInit() and EVP_DigestVerifyUpdate() return 1 for success and 0 for failure.
EVP_DigestVerifyFinal() and EVP_DigestVerify() return 1 for success; any other value indicates failure. A return value of zero indicates that the signature did not verify successfully (that is, tbs did not match the original data or the signature had an invalid form), while other values indicate a more serious error (and sometimes also indicate an invalid signature form).
The error codes can be obtained from ERR_get_error(3).
The EVP interface to digital signatures should almost always be used in preference to the low-level interfaces. This is because the code then becomes transparent to the algorithm used and much more flexible.
EVP_DigestVerify() is a one shot operation which verifies a single block of data in one function. For algorithms that support streaming it is equivalent to calling EVP_DigestVerifyUpdate() and EVP_DigestVerifyFinal(). For algorithms which do not support streaming (e.g. PureEdDSA) it is the only way to verify data.
In previous versions of OpenSSL there was a link between message digest types and public key algorithms. This meant that "clone" digests such as EVP_dss1() needed to be used to sign using SHA1 and DSA. This is no longer necessary and the use of clone digest is now discouraged.
For some key types and parameters the random number generator must be seeded. If the automatic seeding or reseeding of the OpenSSL CSPRNG fails due to external circumstances (see RAND(7)), the operation will fail.
The call to EVP_DigestVerifyFinal() internally finalizes a copy of the digest context. This means that EVP_VerifyUpdate() and EVP_VerifyFinal() can be called later to digest and verify additional data.
EVP_DigestVerifyInit() and EVP_DigestVerifyInit_ex() functions can be called multiple times on a context and the parameters set by previous calls should be preserved if the pkey parameter is NULL. The call then just resets the state of the ctx.
EVP_DigestSignInit(3), EVP_DigestInit(3), evp(7), HMAC(3), MD2(3), MD5(3), MDC2(3), RIPEMD160(3), SHA1(3), openssl-dgst(1), RAND(7)
EVP_DigestVerifyInit(), EVP_DigestVerifyUpdate() and EVP_DigestVerifyFinal() were added in OpenSSL 1.0.0.
EVP_DigestVerifyInit_ex() was added in OpenSSL 3.0.
EVP_DigestVerifyUpdate() was converted from a macro to a function in OpenSSL 3.0.
Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at https://www.openssl.org/source/license.html.


---
layout: default
---
{% include jumbotron.html %}
{% include services.html %}
{% include projects.html %}
{% include testimonials.html %}
{% include team.html %}
{% comment %}
{% include contact.html %}
These sections are commented out:
{% include about.html %}
{% include clients.html %}
{% endcomment %}


If the file data representation is other than ``native,'' care must be taken in constructing etypes and filetypes. Any of the datatype constructor functions may be used; however, for those functions that accept displacements in bytes, the displacements must be specified in terms of their values in the file for the file data representation being used. MPI will interpret these byte displacements as is; no scaling will be done. The function MPI_FILE_GET_TYPE_EXTENT can be used to calculate the extents of datatypes in the file. For etypes and filetypes that are portable datatypes (see Section Semantic Terms , page Semantic Terms ), MPI will scale any displacements in the datatypes to match the file data representation. Datatypes passed as arguments to read/write routines specify the data layout in memory; therefore, they must always be constructed using displacements corresponding to displacements in memory.
Advice to users.
One can logically think of the file as if it were stored in the memory of a
file server. The etype and filetype are interpreted
as if they were defined at this file server, by the same sequence of
calls used to define them at the calling process. If the data
representation is ``native'', then this logical file server runs on the
same architecture as the calling process, so that these types define
the same data layout on the file as they would define in the memory of
the calling process. If the etype and filetype are
portable datatypes, then the data layout defined in the file is the
same as would be defined in the calling process memory, up to a scaling
factor. The routine
MPI_FILE_GET_FILE_EXTENT
can be used to
calculate this scaling factor. Thus, two equivalent, portable
datatypes will define the same data layout in the file, even in a
heterogeneous environment with ``internal'', ``external32'', or user
defined data representations. Otherwise, the etype and
filetype must be constructed so that their typemap and extent
are the same on any architecture. This can be achieved if
they
have an explicit upper bound and lower bound (defined either using
MPI_LB and MPI_UB markers, or using
MPI_TYPE_CREATE_RESIZED). This condition must also be
fulfilled by any datatype that is used in the construction of the
etype and filetype, if this datatype is replicated
contiguously, either explicitly, by a call to
MPI_TYPE_CONTIGUOUS, or implictly, by a blocklength argument
that is greater than one. If an etype or filetype is
not portable, and has a typemap or extent that is architecture
dependent, then the data layout specified by it on a file is
implementation dependent.
File data representations other than ``native'' may
be different from corresponding data representations in
memory. Therefore, for these file data representations,
it is important not to use hardwired byte offsets for
file positioning, including the initial displacement that
specifies the view.
When a portable datatype
(see Section Semantic Terms
, page Semantic Terms
)
is used in a data access operation,
any holes in the datatype are scaled to match the data representation.
However,
note that this technique only works when all the processes
that created the file view build their etypes from the same
predefined datatypes.
For example, if one
process
uses an etype built from MPI_INT
and another uses an etype built from MPI_FLOAT,
the resulting views
may
be nonportable because the relative
sizes of these types may differ from one data representation to another.
( End of advice to users.)
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent)
Returns the extent of datatype in the file fh.
This extent will be the same for all processes accessing
the file fh.
If the current view uses a user-defined data representation
(see Section User-Defined Data Representations
, page User-Defined Data Representations
),
MPI uses the dtype_file_extent_fn callback
to calculate the extent.
In the case of user-defined data representations,
the extent of a derived datatype can be calculated
by first determining the extents of the predefined datatypes
in this derived datatype using dtype_file_extent_fn
(see Section User-Defined Data Representations
, page User-Defined Data Representations
).
( End of advice to implementors.)
MPI_FILE_GET_TYPE_EXTENT(fh, datatype, extent) IN fh file handle (handle) IN datatype datatype (handle) OUT extent datatype extent (integer)
MPI_FILE_GET_TYPE_EXTENT(FH, DATATYPE, EXTENT, IERROR)
INTEGER FH, DATATYPE, IERROR
INTEGER(KIND=MPI_ADDRESS_KIND) EXTENT
{ MPI::Aint MPI::File::Get_type_extent(const MPI::Datatype& datatype) const (binding deprecated, see Section Deprecated since MPI-2.2
) }
Advice
to implementors.
Up: File Interoperability
Next: External Data Representation: ``external32''
Previous: File Interoperability
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009


--- title: "Environmental Protection is What We Care About!" author: "Yuyan Xu" date: 2020-09-26T21:13:14-05:00 bibliography: references.bib categories: ["R"] tags: ["R Markdown", "plot", "regression"] ---
Based on the analyze of the Campaign Period Survey (the CPS) completed in 2008, voters value the environment protection and they seem to expect the leader to pay more attention in environmental issue, along with health care system.
In this repot, I investigated the 2008 CES dataset (Hodgetts and Alexander (2020)), which is short for Canadian Election Study. The CES consists 3 surveys that were conducted during the second half of the election campaign and there were about 4500 eligible voters participated in the survey. This dataset effectively reflects the politics of scale of Canadaian voters, and how they generally expect from the country leader.
There were 3 surveys completed: Campaign Period Survey, Post Election Survey and Mailback Survey. As their names suggested, these surveys were taken at different times around the time of 2008 Canadian Election. All surveys were completed by respondents via web, mail or telephone.I chose to focus on the data provided by the campaign period survey (the CPS) due to a large number of variables and observations. An interesting finding of my investigation on this particular subset of data was, a majority of respondents seems to value the environment a lot, which shows that environment protection could be an influential factor in how they vote during election. In fact, when the respondents were asked “What is the most important issue to YOU PERSONALLY in this FEDERAL election? ”, about 10 percent of them chose “environmental/ecological issue”.
Due to a large amount of nonresponses, the findings of this report might not truly reflect on the population of voters.
devtools::install_github("hodgettsp/cesR")
cesR::get_ces(srvy = 'ces2008')
## TO CITE THIS SURVEY FILE: Gidengil, E, Everitt, J, Fournier, P and Nevitte, N. 2009. The 2008 Canadian Election Study [dataset]. Toronto, Ontario, Canada: Institute for Social Research [producer and distributor].
##
## LINK: http://odesi2.scholarsportal.info/webview/index.jsp?v=2&previousmode=table&analysismode=table&study=http%3A%2F%2F<IP_ADDRESS>%3A80%2Fobj%2FfStudy%2FCES-E-2008&mode=documentation&top=yes
So firstly, I created a subset of CES2008 dataset, which randomly select 45 variables and 1000 observations from each of them. The package visdat (Tierney (2017)) gives us a visual representation of the presented data, the grey area are the missing data (nonresponse datapoints). From the graph we can see that the grey area is pretty large, this means there are a fairly amount of nonresponsive answer in the survey. For this issue, I use vis_miss() function to find out the percentage of the missing data, which is 42.1%. This is quite a lot. The functions glimpse() (Wickham et al. (2020)) and skim() (Waring et al. (2020)) gave me a summary of the data information: there are 45 variables with 4495 observations. The variables can be categorized as discrete and numeric, in this subset of data, there are 33 discrete variables and 12 numeric variables.
#Sample size and number of varibales are too large, randomly select 45 variables and look at the <= 1000 observations for each of them.
subset_2008 <- select(ces2008, 26:70)
subset_2008 %>%
sample_n(1000) %>%
vis_dat()
vis_miss(subset_2008, cluster = FALSE, sort_miss = FALSE, show_perc = TRUE,
show_perc_col = TRUE, large_data_size = 9e+05, warn_large_data = TRUE)
glimpse(subset_2008)
## Observations: 4,495
## Variables: 45
## $ ces08_CPS_A2 <dbl+lbl> NA, 57, 65, 94, NA, 10, NA, 10, 75, 57, 57, …
## $ ces08_CPS_A3 <dbl+lbl> 5, 0, 7, 0, 3, 5, 8, 6, 6, 4, 7, …
## $ ces08_CPS_A4 <dbl+lbl> 5, 0, 7, 3, 5, 5, 5, 3, 6, 4, 10, …
## $ ces08_CPS_A5 <dbl+lbl> 5, NA, 6, 0, 3, 5, 1, 1, 3, 4, 10, …
## $ ces08_CPS_B2 <dbl+lbl> NA, 5, 5, NA, NA, 5, NA, 5, 5, NA, NA, …
## $ ces08_CPS_B3A <dbl+lbl> 1, 5, 3, 1, 1, 3, 1, 3, 1, 3, 3, …
## $ ces08_CPS_B4N <dbl+lbl> 2, NA, NA, 3, NA, 1, 2, NA, 3, 1, 3, …
## $ ces08_CPS_B5 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
## $ ces08_CPS_B6 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
## $ ces08_CPS_B7 <dbl+lbl> 1, NA, NA, 5, NA, 5, 1, NA, 1, 5, 1, …
## $ ces08_CPS_B8 <dbl+lbl> 3, NA, NA, 5, NA, 5, 1, NA, 3, 3, 5, …
## $ ces08_CPS_B9 <dbl+lbl> 97, NA, NA, 5, NA, 3, 1, NA, 97, NA, 2, …
## $ ces08_CPS_B10 <dbl+lbl> 4, NA, NA, 3, 97, 2, 97, 97, 97, 97, 97, …
## $ ces08_CPS_1ST <dbl> 1, 1, 3, 4, 2, 3, 2, 4, 4, 1, 4, 1, 1, 1, 2, 3, …
## $ ces08_CPS_2ND <dbl> 2, 4, 1, 2, 4, 3, 3, 2, 3, 2, 1, 3, 1, 3, 3, 2, …
## $ ces08_CPS_3RD <dbl> 2, 1, 1, 1, 1, 2, 2, 3, 2, 2, 3, 2, 4, 4, 2, 4, …
## $ ces08_CPS_4TH <dbl> 3, 4, 2, 2, 4, 1, 2, 4, 1, 1, 2, 1, 4, 4, 3, 4, …
## $ ces08_CPS_E4 <dbl+lbl> 1, 1, NA, 1, NA, 1, NA, NA, NA, NA, NA, …
## $ ces08_CPS_E1 <dbl+lbl> 1, 1, NA, 5, NA, 1, NA, 1, NA, NA, 1, …
## $ ces08_CPS_E2 <dbl+lbl> 1, 1, NA, 5, NA, 1, 5, NA, 1, NA, NA, …
## $ ces08_CPS_E3 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
## $ ces08_CPS_E5 <dbl+lbl> NA, 1, NA, NA, NA, 1, NA, NA, NA, NA, NA, …
## $ ces08_CPS_I0 <dbl+lbl> 3, 5, 5, 7, 3, 5, 5, 3, 5, 3, 7, 3, 3, 3, 5,…
## $ ces08_CPS_I1 <dbl+lbl> 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 3,…
## $ ces08_CPS_I2 <dbl+lbl> 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1,…
## $ ces08_CPS_I3 <dbl+lbl> 2, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1,…
## $ ces08_CPS_I4 <dbl+lbl> 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,…
## $ ces08_CPS_I5 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
## $ ces08_CPS_1ST_PARTY <dbl> 4, 4, 2, 2, 1, 1, 1, 2, 3, 3, 4, 4, 1, 1, 1, 1, …
## $ ces08_CPS_2ND_PARTY <dbl> 4, 4, 1, 1, 4, 2, 2, 1, 2, 3, 1, 2, 1, 4, 2, 2, …
## $ ces08_CPS_3RD_PARTY <dbl> 1, 1, 3, 4, 2, 3, 2, 2, 3, 2, 2, 1, 1, 2, 2, 1, …
## $ ces08_CPS_4TH_PARTY <dbl> 1, 4, 4, 1, 3, 4, 1, 2, 2, 2, 1, 2, 1, 4, 2, 1, …
## $ ces08_CPS_G7 <dbl+lbl> 75, NA, NA, NA, 30, 25, 100, 60, 50,…
## $ ces08_CPS_G8 <dbl+lbl> 0, 25, 75, 5, 50, 60, 80, 60, 50, 60, 30, …
## $ ces08_CPS_G9 <dbl+lbl> 0, 25, NA, 4, 20, 50, 80, 70, 80,…
## $ ces08_CPS_G10 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
## $ ces08_CPS_G11 <dbl+lbl> 0, NA, NA, NA, 20, 10, 40, 50, NA, NA, 0, …
## $ ces08_CPS_1ST_LEADER <dbl> 3, 3, 3, 1, 1, 2, 2, 1, 1, 1, 3, 1, 3, 2, 3, 2, …
## $ ces08_CPS_2ND_LEADER <dbl> 2, 2, 3, 1, 4, 4, 2, 2, 1, 1, 1, 2, 2, 2, 3, 2, …
## $ ces08_CPS_3RD_LEADER <dbl> 2, 4, 1, 4, 4, 4, 1, 2, 3, 4, 1, 1, 3, 4, 4, 4, …
## $ ces08_CPS_4TH_LEADER <dbl> 1, 3, 4, 3, 3, 4, 4, 2, 3, 1, 1, 2, 1, 2, 3, 2, …
## $ ces08_CPS_G1 <dbl+lbl> 75, 30, 70, 0, 50, 20, 50, 50, 50,…
## $ ces08_CPS_G2 <dbl+lbl> 0, 25, 70, NA, 0, 50, 80, 60, 50,…
## $ ces08_CPS_G3 <dbl+lbl> 0, 25, NA, 6, 997, 60, 50, 70, 50,…
## $ ces08_CPS_G4 <dbl+lbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, …
skimr::skim(subset_2008)
| Name | subset_2008 |
| Number of rows | 4495 |
| Number of columns | 45 |
| _______________________ | |
| Column type frequency: | |
| character | 33 |
| numeric | 12 |
| ________________________ | |
| Group variables | None |
Variable type: character
| skim_variable | n_missing | complete_rate | min | max | empty | n_unique | whitespace |
|---|---|---|---|---|---|---|---|
| ces08_CPS_A2 | 1712 | 0.62 | 1 | 2 | 0 | 47 | 0 |
| ces08_CPS_A3 | 1266 | 0.72 | 1 | 2 | 0 | 11 | 0 |
| ces08_CPS_A4 | 1269 | 0.72 | 1 | 2 | 0 | 11 | 0 |
| ces08_CPS_A5 | 1285 | 0.71 | 1 | 2 | 0 | 11 | 0 |
| ces08_CPS_B2 | 2661 | 0.41 | 1 | 1 | 0 | 2 | 0 |
| ces08_CPS_B3A | 1481 | 0.67 | 1 | 1 | 0 | 4 | 0 |
| ces08_CPS_B4N | 2540 | 0.43 | 1 | 2 | 0 | 8 | 0 |
| ces08_CPS_B5 | 4065 | 0.10 | 1 | 2 | 0 | 7 | 0 |
| ces08_CPS_B6 | 4378 | 0.03 | 1 | 2 | 0 | 7 | 0 |
| ces08_CPS_B7 | 2286 | 0.49 | 1 | 1 | 0 | 2 | 0 |
| ces08_CPS_B8 | 2176 | 0.52 | 1 | 1 | 0 | 4 | 0 |
| ces08_CPS_B9 | 2285 | 0.49 | 1 | 2 | 0 | 7 | 0 |
| ces08_CPS_B10 | 1638 | 0.64 | 1 | 2 | 0 | 7 | 0 |
| ces08_CPS_E4 | 2043 | 0.55 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_E1 | 2104 | 0.53 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_E2 | 1901 | 0.58 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_E3 | 3801 | 0.15 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_E5 | 3220 | 0.28 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_I0 | 1352 | 0.70 | 1 | 1 | 0 | 4 | 0 |
| ces08_CPS_I1 | 1267 | 0.72 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_I2 | 1268 | 0.72 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_I3 | 1257 | 0.72 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_I4 | 1253 | 0.72 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_I5 | 3625 | 0.19 | 1 | 1 | 0 | 3 | 0 |
| ces08_CPS_G7 | 1427 | 0.68 | 1 | 3 | 0 | 63 | 0 |
| ces08_CPS_G8 | 1433 | 0.68 | 1 | 3 | 0 | 63 | 0 |
| ces08_CPS_G9 | 1480 | 0.67 | 1 | 3 | 0 | 67 | 0 |
| ces08_CPS_G10 | 3663 | 0.19 | 1 | 3 | 0 | 40 | 0 |
| ces08_CPS_G11 | 1886 | 0.58 | 1 | 3 | 0 | 61 | 0 |
| ces08_CPS_G1 | 1376 | 0.69 | 1 | 3 | 0 | 59 | 0 |
| ces08_CPS_G2 | 1424 | 0.68 | 1 | 3 | 0 | 60 | 0 |
| ces08_CPS_G3 | 1429 | 0.68 | 1 | 3 | 0 | 60 | 0 |
| ces08_CPS_G4 | 3653 | 0.19 | 1 | 3 | 0 | 39 | 0 |
Variable type: numeric
| skim_variable | n_missing | complete_rate | mean | sd | p0 | p25 | p50 | p75 | p100 | hist |
|---|---|---|---|---|---|---|---|---|---|---|
| ces08_CPS_1ST | 1238 | 0.72 | 2.52 | 1.11 | 1 | 2 | 3.0 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_2ND | 1264 | 0.72 | 2.52 | 1.12 | 1 | 2 | 3.0 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_3RD | 1273 | 0.72 | 2.49 | 1.13 | 1 | 1 | 2.0 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_4TH | 1282 | 0.71 | 2.48 | 1.12 | 1 | 1 | 2.0 | 3 | 4 | ▇▇▁▇▇ |
| ces08_CPS_1ST_PARTY | 1238 | 0.72 | 2.51 | 1.11 | 1 | 2 | 3.0 | 3 | 4 | ▇▇▁▇▇ |
| ces08_CPS_2ND_PARTY | 1279 | 0.72 | 2.50 | 1.12 | 1 | 2 | 2.5 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_3RD_PARTY | 1292 | 0.71 | 2.49 | 1.12 | 1 | 1 | 2.0 | 3 | 4 | ▇▇▁▇▇ |
| ces08_CPS_4TH_PARTY | 1299 | 0.71 | 2.51 | 1.11 | 1 | 2 | 3.0 | 3 | 4 | ▇▇▁▇▇ |
| ces08_CPS_1ST_LEADER | 1238 | 0.72 | 2.52 | 1.10 | 1 | 2 | 3.0 | 3 | 4 | ▇▇▁▇▇ |
| ces08_CPS_2ND_LEADER | 1280 | 0.72 | 2.54 | 1.11 | 1 | 2 | 3.0 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_3RD_LEADER | 1298 | 0.71 | 2.51 | 1.13 | 1 | 1 | 3.0 | 4 | 4 | ▇▇▁▇▇ |
| ces08_CPS_4TH_LEADER | 1300 | 0.71 | 2.47 | 1.12 | 1 | 1 | 2.0 | 3 | 4 | ▇▇▁▇▇ |
The variables I chose to focus were the discrete variables: ces08_CPS_I4 (Importance: Protecting the environment?) and ces08_CPS_A2 (What is the most important issue to YOU PERSONALLY in this FEDERAL election?). This is because, from the data summary above, ces08_CPS_I4 had the highest completion rate with 72.1%. Also, the reason I chose ces08_CPS_A2 was to investigate whether environment protection is one of the major factors that Canadians took into considerations when they vote. At the same time, ces08_CPS_A2 had a completion rate of 61.9%, not so bad.
Then, I used filter() (Wickham et al. (2020)) to filter out all the respondents that chose option 1 for ces08_CPS_I4, which means they thought environment protection is very important. Then, I created a data summary for ces08_CPS_A2 in this particular subset. Also, I used select() (Wickham et al. (2020)) to select out these two variables and compare their statistics alone. As we can see here, ces_CPS_I4 has a median of 1 and the mean is 1.3, this means a lot of people chose option 1. For ces08_CPS_A2 though, the mean is 48 and median is 57, so far, not much can tell from this.
#Look at the data summary of ces08_CPS_A2 in the subset of people chose "very important" or "somewhat important" in ces08_CPS_I4.
subset2_2008 <-
subset_2008 %>%
filter(ces08_CPS_I4 <= 2)
summary(subset2_2008$ces08_CPS_A2)
## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
## 1.00 30.00 57.00 49.12 65.00 97.00 453
#Compare the data summaries of both of the variables.
subset3_2008 <-
subset_2008 %>%
select(ces08_CPS_I4,ces08_CPS_A2)
summary(subset3_2008)
## ces08_CPS_I4 ces08_CPS_A2
## Min. :1.000 Min. : 1.00
## 1st Qu.:1.000 1st Qu.:30.00
## Median :1.000 Median :57.00
## Mean :1.358 Mean :48.81
## 3rd Qu.:2.000 3rd Qu.:65.00
## Max. :3.000 Max. :97.00
## NA's :1253 NA's :1712
I created histograms and bar graphs for each of the two variables.
#Histograms
subset_2008 %>%
ggplot(aes(x = ces08_CPS_I4)) +
geom_histogram(binwidth = 0.5)
## Don't know how to automatically pick scale for object of type haven_labelled/vctrs_vctr/double. Defaulting to continuous.
## Warning: Removed 1253 rows containing non-finite values (stat_bin).
subset_2008 %>%
ggplot(aes(x = ces08_CPS_A2)) +
geom_histogram(binwidth = 0.5)
## Don't know how to automatically pick scale for object of type haven_labelled/vctrs_vctr/double. Defaulting to continuous.
## Warning: Removed 1712 rows containing non-finite values (stat_bin).
#Bar Graphs
subset_2008 %>%
ggplot(aes(x = ces08_CPS_I4)) +
geom_bar()
## Don't know how to automatically pick scale for object of type haven_labelled/vctrs_vctr/double. Defaulting to continuous.
## Warning: Removed 1253 rows containing non-finite values (stat_count).
subset_2008 %>%
ggplot(aes(x = ces08_CPS_A2)) +
geom_bar()
## Don't know how to automatically pick scale for object of type haven_labelled/vctrs_vctr/double. Defaulting to continuous.
## Warning: Removed 1712 rows containing non-finite values (stat_count).
In the histogram below I find that the distribution of how people view of environment protection heavily skewed towards "very important".
subset_2008 %>%
ggplot(aes(x = ces08_CPS_I4)) +
geom_histogram()+
labs(x = "Degree of Agreeance",
y = "Number",
title = "Distribution of agreement in the importance of protecting environment in 2008 CES",
caption = "Source: Gidengil, E, Everitt, J, Fournier, P and Nevitte, N. 2009.") +
theme_bw()
## Don't know how to automatically pick scale for object of type haven_labelled/vctrs_vctr/double. Defaulting to continuous.
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
## Warning: Removed 1253 rows containing non-finite values (stat_bin).
From the graphs above, there were over 3000 people voted "very important" and "somewhat important" when they were asked the level of importance in protecting environment; and about 300 people voted that they considered environmental/ecological issue as the most imporant issue during the federal election. One thing worth mentioning about the dataset was, there were over 600 people voted "economy issues" was the most important issue to them personally; and there were over 500 people voted "health care issues". The "environmental issues" ranked the third in this question.
It shows that environemntal problem has became a huge topic that grab a lot of attention not only from many governmental authorities, but also from the general citizens. It is one of the most influential factors when Canadian citizens vote during federal election.
This report has several weaknesses that need to be paid attention in future study. First, only 45 variables were chosen to analyze while there is a total of 541 variables in the dataset. This means that the statistical summaries in this report is not thorough enough and the final finding might not be accurate; Second, in the original survey dataset, there are about 42% of the observations missing, which means respondents did not response to some particular questions. This could result in response bias, which might result in inaccurate findings as well. This problem could be avoided if there are fewer questions included in the survey, because I think people’s interests would likely wore down while they are taking the survey with too many questions.
-Gidengil, E, Everitt, J, Fournier, P and Nevitte, N. 2009. The 2008 Canadian Election Study [dataset]. Toronto, Ontario, Canada: Institute for Social Research [producer and distributor].
Paul A. Hodgetts and Rohan Alexander (2020). cesR: Access the CES Datasets a Little Easier.. R package version 0.1.0.
Hadley Wickham, Jim Hester and Winston Chang (2020). devtools: Tools to Make Developing R Packages Easier. https://devtools.r-lib.org/,https://github.com/r-lib/devtools.
R Core Team (2020). R: A language and environment for statistical computing. R, Foundation for Statistical Computing, Vienna, Austria. URL, https://www.R-project.org/.
JJ Allaire and Yihui Xie and Jonathan McPherson and Javier Luraschi and Kevin Ushey and Aron Atkins and Hadley Wickham and Joe Cheng and Winston Chang and Richard Iannone (2020). rmarkdown: Dynamic Documents for R. R package version 2.3. URL https://rmarkdown.rstudio.com.
R packages. Using Visdat. https://cran.r-project.org/web/packages/visdat/vignettes/using_visdat.html
Hodgetts, Paul A., and Rohan Alexander. 2020. CesR: Access the Ces Datasets a Little Easier.
Tierney, Nicholas. 2017. “Visdat: Visualising Whole Data Frames.” JOSS 2 (16). Journal of Open Source Software: 355. doi:10.21105/joss.00355.
Waring, Elin, Michael Quinn, Amelia McNamara, Eduardo Arino de la Rubia, Hao Zhu, and Shannon Ellis. 2020. Skimr: Compact and Flexible Summaries of Data. https://CRAN.R-project.org/package=skimr.
Wickham, Hadley, Romain François, Lionel Henry, and Kirill Müller. 2020. Dplyr: A Grammar of Data Manipulation. https://CRAN.R-project.org/package=dplyr.


To start this client:
- start codegen to produce client proxy from current directory:
staff_codegen -tjsclient -i../client_blocking/src Echo.h -dserviceuri=http://localhost/axis2/services/echo
- download jQuery from http://jquery.com/ site and put it as jquery.js into this directory
- copy staff.js from directory staff/bindings/javascript/client into this directory
- deploy current directory on web server
- click the button
- you should see message box with response from service


LINEAR PROGRESSION
Copyright (c) 1997-2003 Lloyd Krassner
This game is played on an empty 8x8 square board:
- SETUP - Initially, each player drop one stone on an empty cell.
- TURN - At each turn, each player slide (orthogonally or diagonally) one of his stones. Then for each crossed cell, drop a stone if it's empty, or replace by one of his stones if the cell is occupied by an enemy stone.
- If the sliding stone reaches a cell occupied by a friendly stone, it stops.
- A stone cannot move into the last cell occupied by the enemy in the previous turn.
- The original cell, where the movement began, also gets a stone.
- A slide must always pass, at least, thru one empty cell.
- The corner cells cannot be entered and are not used during the game.
- If there is no valid movement, the player passes.
- GOAL - The game ends when both players pass. Wins the one with more stones on the board.
An example Black dropped at b7 and White at e6. Black made a slide until e4 (the marked black stone). Now White can slide in 8 directions. If he slides to the left or the bottom-left, the slide may replace one black stone by a white stone. However, the slide to the south must stop before e4, since this was the last cell occupied be the previous black move.


To Export: Copy and paste the JSON text to file. To Import: Copy JSON text from file, and paste into textbox. Click Import/Update button. (Remember to hit save when you are done.)


Alhi Baba's Kabob Shop
Asiana Noodle House
August First
Church Street Tavern
City Market
Mr. Mikes
New Moon


This section includes more detailed information on how to create a SQL Server 2005 Express Database file for use with DotNetNuke.
1. In Solution Explorer select the App_Data folder, right-click on the folder and select Add New Item....
2. In the Add New Item Dialog, select SQL Database, and click Add
The default database name is Database.mdf. If you decide to use a different filename you will have to edit the connection string in web.config.
Back to Welcome page.


--- title: rl_bolts keywords: fastai sidebar: home_sidebar summary: "rl_bolts is intended to be a package of nuts and bolts of RL algorithms, along with some full implementations of RL algorithms. " description: "rl_bolts is intended to be a package of nuts and bolts of RL algorithms, along with some full implementations of RL algorithms. " ---
rl_bolts is starting as a package of just nuts and bolts of RL, and algorithms (and new nuts and bolts) will be added over time, based on necessity.
git clone https://github.com/jfpettit/rl_bolts.git
cd rl_bolts
pip install -r requirements.txt
Import the bits you need to use in your code.
The bit below sets up an actor-critic network for the CartPole-v1 gym environment.
import rl_bolts.neuralnets as nns
import gym
import torch
env = gym.make("CartPole-v1")
actor_critic = nns.ActorCritic(
env.observation_space.shape[0],
env.action_space
)
We can print out the architecture of our actor_critic net below:
actor_critic
obs = env.reset()
action, logp, value = actor_critic.step(torch.as_tensor(obs, dtype=torch.float32))
The cell above starts the environment in a new episode, and passes it through the actor-critic to get an action, action log probability, and value estimate for the state.
print("action", action)
print("logp", logp)
print("value", value)
While the primary aim of this package is to provide some building blocks for RL algorithms, we'll also provide implementations of a few plug-and-play algorithms. At present, we've implemented PPO
(it still needs to be thoroughly benchmarked, so be aware of that). Here is how to use it.
from rl_bolts.algorithms import PPO # import the PPO algorithm
import pytorch_lightning as pl # PPO is a pytorch-lightning module, so need their library for Trainer.
env_to_train_in = "CartPole-v1" # set env to train PPO in.
agent = PPO(env_to_train_in) # initialize agent
trainer = pl.Trainer(reload_dataloaders_every_epoch=True, max_epochs=1) # set up trainer, in practice you'd set max_epochs to more than one
trainer.fit(agent) # run trainer


ca.ualberta.cs.models
| Constructor and Description |
|---|
Entry(java.lang.String post_,
java.lang.String author_)
Creates a new Entry.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addReplies(Reply reply)
Add a Reply to this Entry.
|
java.lang.String |
getAuthorsName()
Get the name of the person who created this Entry.
|
java.util.Date |
getDate()
Get the date this Entry was made
|
Picture |
getPicture()
Returns the picture attached to this Entry.
|
java.lang.String |
getPost()
Get the post (main body of text) for this Entry.
|
java.util.ArrayList<Reply> |
getReplies()
Get all the replies to this Entry.
|
int |
getUpVote()
Get how many up votes this Entry has.
|
void |
setAuthorName(java.lang.String name)
Set the name of the person who created this Entry.
|
void |
setPicture(Picture pic)
Set the picture attached to this Entry.
|
void |
setPost(java.lang.String s)
Set the post (main body of text) for this Entry.
|
void |
setUpVote(int upVote_)
Set how many up votes this Entry has.
|
public Entry(java.lang.String post_, java.lang.String author_)
post_
- The post (main body of text) of the Entry.author_
- The person who wrote the Entry.public java.util.ArrayList<Reply> getReplies()
public void addReplies(Reply reply)
reply
- The Reply to add.public int getUpVote()
public void setUpVote(int upVote_)
upVote_
- How many up votes this entry has.public java.lang.String getPost()
public void setPost(java.lang.String s)
s
- The post (main body of text) for this Entry.public java.lang.String getAuthorsName()
public void setAuthorName(java.lang.String name)
name
- The person who created this Entry.public java.util.Date getDate()
public void setPicture(Picture pic)
pic
- The picture.public Picture getPicture()


What is ESC Affiliation?
ESC affiliation is a process through which engineering student organizations at Berkeley demonstrate their commitment to diversity, equity, and inclusion within their organizations. All of our affiliated organizations have attended several mandatory trainings, stripped exclusive requirements from their applications, and provided ESC with feedback from their members regarding the state of club culture at Berkeley. In return, ESC provides these clubs with a wide range of benefits, including access to funding and publicity. Next year, ESC is looking to partner with the College of Engineering and expand this list of benefits, creating an even greater incentive for clubs to join this program.


INSIDE YAHOO!
TOP 20 WEB RESULTS
out of about 7,730,000
- CIA World Factbook: Philippines
includes government, economy, transportation, and transnational issues.
Category: Philippines > Country Guides
www.cia.gov/cia/publications/factbook/geos/rp.html
- 101k
- Cached
- More pages from this site
- Philippines.com -
Philippines.com, PHILIPPINES | PHILIPPINE HOTEL | PHILIPPINE PHONE CARD | MANILLA
| TRAVEL TO PHILIPPINES | PHILIPPINE RESORT, PHILIPPINES. PHILIPPINE HOTEL. ...
www.philippines.com/
- 9k
- Cached
- Lonely Planet: Destination Philippines
information on events, attractions, activities, and transportation for the independent traveller.
Category: Travel Destination Guides > Philippines
www.lonelyplanet.com/destinations/south_east_asia/philippines/
- 31k
- Cached
- More pages from this site
- University of the Philippines Diliman
... University of the Philippines-Diliman, Diliman, Quezon City 1101, Philippines. ... Copyright
© 2000 University of the Philippines-Diliman. ...
www.upd.edu.ph/
- 9k
- Cached
- More pages from this site
- Department of Tourism
official site of the Department of Tourism providing travel and transportation information on the country famous beaches, dive sports, and world heritage sites. Also offers travel packages, trivia, and travel articles.
Category: Philippines > Philippines Department of Tourism
www.tourism.gov.ph/
- 46k
- Cached
- More pages from this site
- Yehey
directory and search engine for Philippine-related sites.
Category: Philippines > Searching The Web > Search Engines and Directories
www.yehey.com/
- 7k
- Cached
- More pages from this site
- National Statistics Office
conducts the national census; compiles and classifies general statistical data.
Category: Philippines > Government > Statistics
www.census.gov.ph/
- 38k
- Cached
- More pages from this site
- Republic of the Philippines
federal government hub site.
Category: Philippines > Government
www.gov.ph/
- 39k
- Cached
- More pages from this site
- Southeast Asian Studies WWW Virtual Library - Philippines
ASIA WWW To IIAS Homepage To Southeast Asian Studies WWWVL. PHILIPPINES. ...
www.iias.nl/wwwvl/southeas/philippi.html
- 3k
- Cached
- More pages from this site
- dotPH - The Official Domain Registry of the Philippines
dotPH is the Official Domain Registry of the Philippines. We offer bulk
.ph domain registration, trademark protection, whois, domain ...
www.domains.ph/Default.asp
- 4k
- Cached
- U.S. Library of Congress Country Study - Philippines
good starting point for learning about the country; includes facts-at-a-glance and sections on history, society and government.
Category: Philippines > Country Guides
lcweb2.loc.gov/frd/cs/phtoc.html
- 23k
- Cached
- PAGASA HOMEPAGE
The official website of the Philippine Atmospheric, Geophysical and Astronomical Services Administration
www.pagasa.dost.gov.ph/
- 2k
- Cached
- University of the Philippines at Los Baños
Category: Philippines > Laguna > Los Baños > University of The Philippines At Los Baños
www.uplb.edu.ph/
- 11k
- Cached
- University of the Philippines System
Category: Philippines > University of The Philippines
www.up.edu.ph/
- 43k
- Cached
- University of the Philippines at Manila
includes admission requirement, academic programmes, and more.
Category: Philippines > Metropolitan Manila Area > Manila > University of The Philippines At Manila
www.upm.edu.ph/
- 4k
- Cached
- Central Bank of the Philippines (Bangko Sentral ng Pilipinas)
Category: Philippines > Banking > Central Banks
www.bsp.gov.ph/
- 20k
- Cached
- More pages from this site
- BusinessWorld
business news from the Philippines.
Category: Philippines > Philippines > Philippines > Business > Newspapers
www.bworld.com.ph/
- 48k
- Cached
- More pages from this site
- Department of Foreign Affairs
Category: Philippines > Government Departments
www.dfa.gov.ph/
- 39k
- Cached
- More pages from this site
- Philippine House of Representatives
information on House Members, House leaders, and various legislative activities.
Category: Philippines > Legislative Branch > House of Representatives
www.congress.gov.ph/
- 38k
- Cached
- Supreme Court of the Philippines
explains judicial system of the country including history, a list of former justices, juriprudence, and more.
Category: Philippines > Supreme Court of The Philippines
www.supremecourt.gov.ph/
- 1k
- Cached
- More pages from this site


Ask your engineering question below
What Would You Like To Search For?
First Year Courses
Recently Asked
Mechanical
Chem Eng
Computer
Geological
Civil
Eng Chem


{% extends "base.html" %}
{% block content %}
{%raw%}
This graphic shows how the total number of similar businesses in your area has evolved over the past few years.
This graphic displays details of the average person in your area of business.
Median Age: {{age}}
Median Income: {{income}}
Dependent Children: {{kids}}
Education Level: {{educ}}
Marital Status: {{marry}}
Weekly Rent: {{rent}}
Number of Cars: {{cars}}
Internet Connection Type: {{net}}
This graph shows the proportion of businesses in your region with similar turnover and number of employees that survive over time. Data is displayed as a percentage of the original sample.
This graphic shows how many people are looking for full-time and part-time work in your area of business.


We aggregate mices!
- productize compelling solutions
- cultivate vertical paradigms
- transition user-centric convergence
- streamline ubiquitous schemas
- mesh innovative solutions
- incubate cutting-edge experiences
- revolutionize e-business platforms
- grow clicks-and-mortar niches
- leverage B2C action-items
- incubate wireless functionalities
- enhance viral initiatives
- transition rich paradigms
- envisioneer robust ROI
- optimize transparent networks


{{ static_info['FQDN'] }}
System
{% for key in static_info.keys()%}
{{ key }}
{{ static_info[key] }}
{% endfor %}
Statistics
Free Memory (MB)
Processes and Open Files


CHARACTERISTICS OF TRANSVERSE MIXING IN OPEN-CHANNEL FLOWS
Thesis by
Josephat Kanayo Okoye
In Partial Fulfillment of the Requirements
For the Degree of
Doctor of Philosophy
California Institute of Technology Pasadena, California 1971
(Submitted November 5, 1970)