- consumables
- CLARITY
- TANGO
- HEALING SALVE
- SMOKE OF DECEIT
- TOWN PORTAL SCROLL
- DUST OF APPEARANCE
- ANIMAL COURIER
- FLYING COURIER
- OBSERVER WARD
- SENTRY WARD
- BOTTLE
- attributes
- IRON BRANCH
- GAUNTLETS OF STRENGTH
- SLIPPERS OF AGILITY
- MANTLE OF INTELLIGENCE
- CIRCLET
- BELT OF STRENGTH
- BAND OF ELVENSKIN
- ROBE OF THE MAGI
- OGRE CLUB
- BLADE OF ALACRITY
- STAFF OF WIZARDRY
- ULTIMATE ORB
- armaments
- RING OF PROTECTION
- QUELLING BLADE
- STOUT SHIELD
- BLADES OF ATTACK
- CHAINMAIL
- HELM OF IRON WILL
- BROADSWORD
- QUARTERSTAFF
- CLAYMORE
- JAVELIN
- PLATEMAIL
- MITHRIL HAMMER
- arcane
- MAGIC STICK
- SAGE'S MASK
- RING OF REGEN
- BOOTS OF SPEED
- GLOVES OF HASTE
- CLOAK
- GEM OF TRUE SIGHT
- MORBID MASK
- GHOST SCEPTER
- TALISMAN OF EVASION
- BLINK DAGGER
- SHADOW AMULET
- common
- WRAITH BAND
- NULL TALISMAN
- MAGIC WAND
- BRACER
- POOR MAN'S SHIELD
- SOUL RING
- PHASE BOOTS
- POWER TREADS
- OBLIVION STAFF
- PERSEVERANCE
- HAND OF MIDAS
- BOOTS OF TRAVEL
- support
- RING OF BASILIUS
- HEADDRESS
- BUCKLER
- URN OF SHADOWS
- RING OF AQUILA
- TRANQUIL BOOTS
- MEDALLION OF COURAGE
- ARCANE BOOTS
- DRUM OF ENDURANCE
- VLADMIR'S OFFERING
- MEKANSM
- PIPE OF INSIGHT
- caster
- FORCE STAFF
- NECRONOMICON
- EUL'S SCEPTER OF DIVINITY
- DAGON
- VEIL OF DISCORD
- ROD OF ATOS
- AGHANIM'S SCEPTER
- ORCHID MALEVOLENCE
- REFRESHER ORB
- SCYTHE OF VYSE
- weapons
- CRYSTALYS
- ARMLET OF MORDIGGIAN
- SKULL BASHER
- SHADOW BLADE
- BATTLE FURY
- ETHEREAL BLADE
- RADIANCE
- MONKEY KING BAR
- DAEDALUS
- BUTTERFLY
- DIVINE RAPIER
- ABYSSAL BLADE
- armor
- HOOD OF DEFIANCE
- BLADE MAIL
- VANGUARD
- SOUL BOOSTER
- BLACK KING BAR
- SHIVA'S GUARD
- MANTA STYLE
- BLOODSTONE
- LINKEN'S SPHERE
- ASSAULT CUIRASS
- HEART OF TARRASQUE
- artifacts
- HELM OF THE DOMINATOR
- MASK OF MADNESS
- SANGE
- YASHA
- MAELSTROM
- DIFFUSAL BLADE
- DESOLATOR
- HEAVEN'S HALBERD
- SANGE AND YASHA
- MJOLLNIR
- EYE OF SKADI
- SATANIC
- secret
- DEMON EDGE
- EAGLESONG
- REAVER
- SACRED RELIC
- HYPERSTONE
- RING OF HEALTH
- VOID STONE
- MYSTIC STAFF
- ENERGY BOOSTER
- POINT BOOSTER
- VITALITY BOOSTER
- ORB OF VENOM


/home/tungly/env/projects/l42
/
vendor
/
laravel
/
framework
/
src
/
Illuminate
/
Auth
(Dashboard)
Class Coverage Distribution
Class Complexity
Top Project Risks
Guard
(3526)
EloquentUserProvider
(60)
AuthManager
(20)
Least Tested Methods
Guard::queueRecallerCookie
(0%)
Guard::onceUsingId
(0%)
Guard::createRecaller
(0%)
Guard::logout
(0%)
Guard::clearUserDataFromStorage
(0%)
Guard::loginUsingId
(0%)
Guard::updateSession
(0%)
AuthManager::callCustomCreator
(0%)
Guard::fireAttemptEvent
(0%)
Guard::attempting
(0%)


Save an array to a binary file. More...
Functions | |
| AFAPI int | saveArray (const char *key, const array &arr, const char *filename, const bool append=false) |
| AFAPI af_err | af_save_array (int *index, const char *key, const af_array arr, const char *filename, const bool append) |
Save an array to a binary file.
The saveArray and readArray functions are designed to provide store and read access to arrays using files written to disk.
The format of the file (version 1) is as follows:
Header:
| Description | Data Type | Size (Bytes) | Detailed Desc |
|---|---|---|---|
| Version | Char | 1 | ArrayFire File Format Version for future use. Currently set to 1 |
| Array Count | Int | 4 | No. of Arrays stored in file |
Per Array:
| Description | Data Type | Size (Bytes) | Detailed Desc |
|---|---|---|---|
| Length of Key String | Int | 4 | No. of characters (excluding null ending) in the key string |
| Key | Char [] | length | Key of the Array. Used when reading from file |
| Offset | Int64 | 8 | No of bytes between offset and start of next array |
| Array Type | Char | 1 | Type corresponding to af_dtype enum |
| Dims (4 values) | Int64 | 4 * 8 = 32 | Dimensions of the Array |
| Data | Type | sizeof(Type) * dims.elements() | Actual data of the array |
The offset is equal to 1 byte (type) + 32 bytes (dims) + size of data.
An file with 2 arrays would look like (representative)
1
2
Array 1 Key Length
Array 1 Key
Array 1 Offset
Array 1 Type
Array 1 Dims
Array 1 Data
Array 2 Key Length
Array 2 Key
Array 2 Offset
Array 2 Type
Array 2 Dims
Array 2 Data
Save array allows you to append any number of Arrays to the same file using the append argument. If the append argument is false, then the contents of the file are discarded and new array is written anew.
On each append, the array counter in the header is incremented and the new array is written to the end of the file. This function does not check if the tag is unique or not.
| AFAPI af_err af_save_array | ( | int * | index, |
| const char * | key, | ||
| const af_array | arr, | ||
| const char * | filename, | ||
| const bool | append | ||
| ) |
| [out] | index | is the index location of the array in the file |
| [in] | key | is an expression used as tag/key for the array during af::readArray() |
| [in] | arr | is the array to be written |
| [in] | filename | is the path to the location on disk |
| [in] | append | is used to append to an existing file when true and create or overwrite an existing file when false |
| AFAPI int saveArray | ( | const char * | key, |
| const array & | arr, | ||
| const char * | filename, | ||
| const bool | append = false |
||
| ) |
| [in] | key | is an expression used as tag/key for the array during readArray |
| [in] | arr | is the array to be written |
| [in] | filename | is the path to the location on disk |
| [in] | append | is used to append to an existing file when true and create or overwrite an existing file when false |


You can easily control dropdowns programmatically using the exported dropdown instance.
Bootstrap split buttons and dropdowns on button groups are supported with the existing dropdown directives.
This dropdown uses customized default values.


Class: ActionDispatch::ServerTiming::Subscriber
Do not use. This class is for internal use only.
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Instance Chain:
self,
::Singleton
|
|
| Inherits: | Object |
| Defined in: | actionpack/lib/action_dispatch/middleware/server_timing.rb |
Constant Summary
-
KEY =
# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 11:action_dispatch_server_timing_events
Class Method Summary
- .new ⇒ Subscriber constructor
Instance Attribute Summary
::Singleton
- Included
| #duplicable? |
|
Instance Method Summary
Constructor Details
.new ⇒ Subscriber
# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 13
def initialize @mutex = Mutex.new end
Instance Method Details
#call(event)
[ GitHub ]# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 17
def call(event) if events = ActiveSupport::IsolatedExecutionState[KEY] events << event end end
#collect_events
[ GitHub ]# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 23
def collect_events events = [] ActiveSupport::IsolatedExecutionState[KEY] = events yield events ensure ActiveSupport::IsolatedExecutionState.delete(KEY) end
#ensure_subscribed
[ GitHub ]# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 32
def ensure_subscribed @mutex.synchronize do # Subscribe to all events, except those beginning with "!" # Ideally we would be more selective of what is being measured @subscriber ||= ActiveSupport::Notifications.subscribe(/\A[^!]/, self) end end
#unsubscribe
[ GitHub ]# File 'actionpack/lib/action_dispatch/middleware/server_timing.rb', line 40
def unsubscribe @mutex.synchronize do ActiveSupport::Notifications.unsubscribe @subscriber @subscriber = nil end end


First, we need to learn some basic HTML.
Things to get done today:
My favorite song albums by Drake:
Sometimes, you need to draw attention to a particular word or phrase.
Other times you need to strongly emphasize the importance of a word or phrase.
And sometimes you need to shout!
Thanks for reading! Interneting should be getting easier now.
Regards,
The Authors
P.S.
This example is about links and images.
This particular page is about links! There are three kinds of links:
This page is about miscellaneous HTML things, but you may also be interested in links or images.
This page covers common image formats, but you may also be looking for links and useful extras.
JPG images are good for photos.
GIFs are good for animations.
PNGs are good for diagrams and icons.
SVGs are amazing. Use them wherever you can.


| DOSE: T+ 0:00 |
25 mg |
oral |
2C-C |
(powder / crystals) |
| T+ 2:00 |
8.0 mg |
insufflated |
2C-C |
(powder / crystals) |
| T+ 3:00 |
0.5 mg |
oral |
Pharms - Alprazolam |
(pill / tablet) |
| T+ 3:00 |
1 hit |
smoked |
Cannabis |
(plant material) |
I decided to try it for myself. The reasoning was simple: It might have fun properties, and it's one of the few research chemicals that can still be found online.
Anyway, I bought 100mg from an internet source. It arrived in 3 days, and I was ready to try it immediately. The experience went as follows.
20:30 - Two friends and I dosed, 25mg each, by 'parachuting' it in a piece of toilet paper. We had eaten a few hours before, but nothing recently.
21:00 - I stated to feel a come-on, my friends hadn't felt anything yet. We weren't worried, since they say it takes a while to kick in. We were sitting on the couch watching Simpsons, waiting, waiting.
22:00 - By this point, I was definitely feeling something. We had just gone shopping for dinner food , and the experience was definitely altered by the drug, albeit only slightly. It was sort of like MDMA, or 2C-I, but with a slight headache.
22:30 - After making food, I suggested that we split the other 25mgs between the 3 of us. We divided it up into lines, and insufflated them. (Approximately 8mgs was insufflated by each of us.) It burned for a minute, but it was a very localized burn, and it wasn't uncomfortable at all.
22:40 - The recent bump seems to have significantly amplified the effects. I can feel a warm head rush, and the urge to smile. My friends felt something, although they weren't very vocal about it, which leads me to believe it was relatively minor.
23:30 - The effects had almost completely worn off by now, both from the original dose and the bump later on. We had just eaten dinner, and were felling pretty normal. We drank some Sparks energy drink, took .5mg xanax per person, smoked a hit or two of weed, and watched Pirates of the Carribean.
The after effects were non-existent. There was no hangover, no body ache, no headache, nothing. This could be attributed to the short duration and mild effect of the drug.
Overall it was a very mild experience. None of us was terribly impressed. However, none of us regretted trying it, either.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Stephen Platz
Growing up in central New York state, Steve has always had a fondness for the outdoors and enjoys cross country skiing, sailing, paddling and pedaling whenever he can. As a classically trained multi instrumentalist and artist, Steve began using personal computers to explore digital media, spending hours in front of a screen in the dark developing sounds and images in code.
After pursuing interests in sustainable agriculture and traditional boatbuilding, he began his academic work focusing on comparative studies, recognizing persistent concerns he had with the synthesis of theory and practice in creative disciplines. As a graduate student, Steve studied philosophy and media at a small university campus in the Swiss Alps.
At some point, Steve began producing sites on the web and has since been active in utilizing this technology as a resource to disseminate knowledge and build communities. His current work focuses on using Drupal and other open-source web technologies to enable and enrich communities, increasing our sensitivity and compassion for others, rather than distancing us from the work of human relations. After many years working in a Manhattan design studio, Steve was drawn to CoLab by their unique cooperative structure and commitment to working with human-centered organizations.


class: center, title # How to Learn C *An introduction for the high-level programmer* --- # Prerequisite knowledge ### 1. At least one programming language Preferably two, because you'll know how to logically solve a problem, but express it in two different ways. *Don't pick C as your first language.* ### 2. Logical thinking You must be able to break down a problem into simple steps the computer can understand. If you can't think like a computer, you'll have difficulty debugging. ### 3. Time C isn't a language you'll quickly learn. You'll write programs that don't work right. It takes time before you can quickly spot issues in your code. --- # Why you should learn C
You only need C for projects that require low-level hardware access or blazing-fast speeds.
### 1. Advanced Game Development (coupled with a good game development framework) For *advanced* high-performance 3D graphics intensive applications. *
You'd better have some math knowledge (linear algebra, calculus and college physics) for that, too.
* ### 2. Compilers Get a book on compiler design for this stuff. ### 3. Embedded Applications When you're trying to eek out every last bit of performance, you're probably not going to flash your microcontroller with a Ruby interpreter so you can run a script. --- # Why you should learn C (cont) ### 4. Operating Systems YAH! LINUX!!! Or your own homebrew OS if you want. ### 5. LINUX YAH! LINUX!!! Kernel hackering, command line utility development, writing a replacement to systemd, etc.
If you're looking to write a script that counts the number of occurrences of 'foo' in a text file, you're in the wrong place. --- class: center, middle, dark # If you're still sure you want to learn C, take a quick look at a guide to syntax so you have an idea of what's going on. --- class: center, middle, dark # This slideshow is to help you learn and understand the more confusing concepts C introduces. --- class: center, middle, dark # On to the technical stuff --- class: center, middle, dark ### Interpreted vs ### Compiled --- # Example ### Ruby As soon as you've finished writing your code, you can run it. The Ruby interpreter will execute the code on the fly: ```bash ruby test.rb #=> Yah! Running code! ``` ### C C requires that you **compile** your code to an machine-code executable file first. ```bash # Compile my shizzle to a new executable called 'test' cc -o test test.c # Run my shizzle ./test ``` --- ## Advantages - Easy to redistribute - Fast - Automatic obfuscation (they can't read your code!) - The compiler essentially lints your code ## Disadvantages - Must be compiled on every architecture - More difficult to debug --- class: center, middle, dark ### Dynamic typing vs ### Static typing --- # Example ### Ruby Variables can be anything! ```ruby my_var = 4 # Look, it's an integer my_var = 2.0 # Now it's a float my_var = [1,2,3] # Woah, an array! my_var = 'a string of stuff' # WORDS! (a.k.a. string) ``` ### C Once you've set the type for your variable, it must stay that way forever. ```c int my_var = 3; // It's an int! my_var = "abc"; // COMPILER ERROR!  Have some garbage! //=> ajskdi&E3j ... Error: segfault ``` --- class: center, middle, dark ### Automatic Memory Layout and Garbage Collection vs ### Manual Memory Layout and Management --- # Example ### Ruby ```ruby def my_memory_function cats = get_all_teh_images_on_imgur process_images(cats) # Whoa, it's is takin up a lot of memory end # DELETE THE KITTIES # the cats variable doesn't exist anymore!  It's bad.* --- class: center, middle, dark # Onwards! To the confusing things! --- class: center, middle, dark, thehorror #.biggest[Pointers!] --- # Pointers ... are foundational to C. They give you great power (so please be careful). *A pointer is a variable that contains a memory address (probably of another variable).* In C, a '`*`' denotes a variable as a pointer to whatever data type comes before. ```c int *i_ptr; // this pointer can point to an integer float *f_ptr; // this can point to a float int **ii_ptr; // this pointer points to an int pointer ``` The '`&`' symbol allows you to get the memory location to a variable: ```c int x = 3; int *i_ptr = &x; // i_ptr is a pointer to the memory location of 'x' ``` --- Memory is laid out something like this: location | value ---------|------ `0x00` | `0x01` | `0x02` | `0x03` | And a variable is just named memory address: ```c int x = 3; // the compiler picks a memory location. Let's say: 0x01 ``` location | value ---------|------ `0x00` | `0x01` | `3` `0x02` | `0x03` |
In real life, you don't have to know the memory location for variables. This is just for demonstration.
--- If we create a pointer that points to variable `x`: ```c int *i_ptr = &x; // so, i_ptr has to contain 0x01. ``` `i_ptr` is a **variable**, and also **has a location in memory.** Let's say `0x02`. location | value ---------|------ `0x00` | `0x01` | `3` `0x02` | `0x01` `0x03` | If we decided to create an integer pointer pointer (`int **`) to point to `i_ptr`: ```c int **ii_ptr = &i_ptr; // lets say ii_ptr is 0x03 ``` location | value ---------|------ `0x00` | `0x01` | `3` `0x02` | `0x01` `0x03` | `0x02` --- class: center, middle, dark # Great, now we have a pointer to a pointer to an integer. But how do we get the value out? --- This is were the dereference operator '`*`' comes into play. `*` dereferences (or follows) a pointer to the location it points to: ```c int y = *i_ptr; // gives us the value of what i_ptr points to int z = **ii_ptr; // gives follows the first pointer, // then follows the second pointer to the value. ``` I like to think of a pointer as a directory and the value as a file. ``` ─── ii_ptr └── i_ptr └── x ``` Then, '`*`' would move down a directory and '`&`' would move up a directory. --- Wait, but what about multiple files! That would break the analogy! ``` ─── ii_ptr └── i_ptr ├── x └── y ``` Actually, this is how arrays are handled in C. A C array is a set of consecutive memory addresses. The first value is pointed to by a pointer. ```c int a[] = {1, 2, 3}; // create an array // a is just a pointer to the first element... int first_val = *a; //... so dereferencing it will give us the first value. int second_val = *(a + 1); // get the next memory address (a + 1), // then follow (or step into) that memory address ('*') int third_value = a[2]; // this is just syntactic sugar for *(a + 2) ``` --- class: center, middle, dark # There's a limitation to C arrays. --- class: center, middle, dark # They aren't dynamic. --- class: center, middle, dark # You want to push a new element to the end of an array? --- class: center, middle, dark # Guess what, bucko? --- class: center, middle, dark # You have to *manually* allocate space for the new value --- # `malloc` and `realloc` *Manually allocating space in memory since 1972.* `malloc` takes one argument: the number of bytes that need to be allocated. `sizeof(int)` returns the number of bytes in an integer, which we multiply by the number of elements in the array. ```c int num_of_elements = 3; int *resize_arr = malloc(sizeof(int) * num_of_elements); // ... put stuff in it ... ``` To make room for a new element: ```c resize_arr = realloc(resize_arr, sizeof(int) * (num_of_elements + 1)); ``` The first argument is the pointer to reallocate, the second is the new size of the pointer. Don't forget to free it when you're done: ```c free(resize_arr); ``` --- class: center, middle, dark # And finally --- class: center, middle, dark # a concept that not difficult to understand --- class: center, middle, dark # but foundational --- class: center, middle, dark # C doesn't care about your data --- # What does that mean?  You want to cast your integer to a char? Go ahead: ```c char letter = 'a'; int x = (int) a; // look. it's now an int ``` A pointer to an integer: ```c int x = 3; int *ptr = &x; int y = (int) ptr; ``` Does it throw a warning because ints aren't the same size as pointers? Yes. Does it make sense? No. Does C still cast it? Yes. Using an image library and want to cast an int to the first pixel? Go ahead: ```c #include
int num = 30; image *my_img = load_raw_image("./test.png"); my_img[0][0] = (pixel) num; ``` --- class: center, middle, dark # And that covers the all difficult C concepts for beginners --- # What you should remember - C sees the world as a bunch of random bytes - Pointers are just addresses. They are variables too. - Arrays are collections of consecutive memory locations --- # More resources for learning - [The C Programming Language](http://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628), a book by the original creators of C. They know what they're talking about. - An interactive [introduction to C](http://www.learn-c.org/) - A collection of [good blog posts on C](http://www.cprogramming.com/tutorial/c-tutorial.html) --- class: center, middle, dark If you think of anything that could help improve this slideshow, .white[[let me know :)](http://twitter.com/theninjacharlie)] --- class: center, middle, dark created by .white[[@theninjacharlie](http://twitter.com/theninjacharlie)]


Package {experienceAnalysis}
contains a suite of functions for performing text mining such as sentiment analysis, analysis of word counts, TF-IDFs and n-grams etc. The package was developed as a helper package for use with other packages/repos developed by the CDU Data Science Team, but the functions are generic and thus suitable for broader use. The focus is on calculating sentiment indicators and word counts/frequencies for labeled or unlabeled text, and plotting the outcomes to easily detect potentially important information in the text. However, there are a few “spin-off” functions for assessing the performance of a classification model, e.g. calculating accuracy per class, making and plotting confusion matrices etc.
The function documentation is here.
For an example of how the package is used in practice, see the source code for this dashboard.
The package makes extensive use of {tidytext} (Silge & Robinson, 2017).
In line with the broader work of the CDU Data Science Team, all function names have prefixes that give users a hint of what type of operations they perform (e.g. prep_*
and plot_*
for preparing and plotting data respectively). See Naming guidelines for functions.
get_*()
: Get data, e.g. from a database or a file;tidy_*()
: Tidy data, e.g. renaming variables, removing duplicates, creating factors, “wide” to “long” format etc.;collect_*()
: Collect data of specific cases, mainly wrapper functions for specific filter commands;prep_*()
: Prepare data for further use, e.g. to create tables, sorting vectors etc.;Note that the sentiment dictionaries loaded from tidytext (via {textdata}
) do not all have an open licence and users must accept the licence agreement the first time they run these functions. The console prompt to do this is not accessible when deploying this software on a server. Consequently, in order to deploy this application it is necessary to run the contents of the data-raw/
folder. You will need to accept the terms of the licences yourself. When this is done, the data will be accessible to the package in data/
and all of the sentiment dictionary functions will automatically load from this location instead of using the tidytext functions.


{% extends 'tenant_configuration/base.html' %} {% load staticfiles i18n compress thumbnail %} {% block content %} {% compress js inline %} {% include 'tenant_configuration/entrepreneur/2_js.html' %} {% endcompress %}
Now, let's add profile pic to customize your experience - just make sure it is appropriate because it will be viewable by your advisor, your host organization's staff, and entrepreneurs in your class.


Genesis 37:32
And they sent the coat of many colors, and they brought it to their father; and said, This have we found: know now whether it be thy son's coat or no.


Guard Vesa:
The region of Oren is north of Giran. I once had a chance to meet their guards, and they seem to have a very strict military discipline. Isn't it really ironic that the Ivory Tower, the traditional school of magic, is there?
Return


Options for tiler package.
tiler_options(...)
| ... | a list of options. |
|---|
The function prints all set options if called with no arguments. When setting options, nothing is returned.
On Windows systems, if the system paths for python.exe
and
OSGeo4W.bat
are not added to the system PATH variable, they must be
provided by the user after loading the package.
It is recommended to add these to the system path so they do not need to be
specified for every R session.
As long as you are using OSGeo4W, you can ignore the Python path specification and do not even need to install it on your system separately; OSGeo4W will use its own built-in version.
The recommended way to have GDAL available to Python in Windows is to install OSGeo4W. This is commonly installed along with QGIS.
By default, tiler_options
is set on package load with
osgeo4w = "OSGeo4W.bat"
. It is expected that the user has added the
path to this file to the system PATH variable in Windows.
For example, if it is installed to C:/OSGeo4W64/OSGeo4W.bat
, add
C:/OSGeo4W64
to your PATH.
If you do want to specify the path in the R session using
tiler_options
, provide the full path including the filename.
See the example.
None of this applies to other systems. As long as the system requirements,
Python and GDAL, are installed, then tile
should generate tiles
without getting or setting any tiler_options
.
tiler_options()#> $python #> [1] "python" #> #> $osgeo4w #> [1] "OSGeo4W.bat" #>tiler_options(osgeo4w = "C:/OSGeo4W64/OSGeo4W.bat")


Dino Viewer
Select guests
- Select a region by drawing a square on the map
- Select a time interval by dragging on the time-line below
- Click on the get guests button
- Select guests and from the list
- Click on draw
Area
Draw a square
Time
Select from timeline
Subjects
Paths


--- layout: page title: Lean Prover Zulip Chat Archive permalink: archive/113488general/98683recname.html ---
After adding an inductive type to the environment using add_inductive
, I can use the induction
tactic, but it doesn't return any useful case names... Can I solve this by defining rec_name
?
Sounds like it: https://github.com/leanprover/lean/blob/master/library/init/meta/tactic.lean#L425-L426
Good to know that induction
works at all
Yes, that's indeed a good thing. I don't even have to add the using
clause...
Apparently you do, if you want nice case names :)
The alternative is to set the case names on your own, using a wrapper around the induction
tactic
I don't _really_ need the case names so far, but I'm kind of feeling that I don't have enough control over which case belongs to which constructor while the tactic is working on it...
{% endraw %}


Oslo Kotlin Meetup
20.10-2020
- Domain Specific Languages - Marie Katrine Ekeberg
- kscript, scripting with Kotlin - Anders Mikkelsen
- Functional programming with Arrow - Jarle Hansen
Jarle Hansen
Word of warning :)
- My experience with arrow is limited
- If anyone has experience using it in projects I would like to know
Agenda
- What is arrow
- Examples
- Either (core)
- RaceN (fx)
- Optics (optics)
What is arrow
- KΛTEGORY + funKTionale = arrow
- The two most relevant FP libraries for Kotlin in 2017
- Functional companion to Kotlin's Standard Library
Option is deprecated
Option will be deleted soon as it promotes the wrong message of using a slower and memory unfriendly
abstraction when the lang provides a better one
Either
Either is used to short-circuit a computation upon the first error
By convention, the right side of an Either is used to hold successful values
Arrow fx
A next-generation Typed FP Effects Library that makes tracked effectful programming first class in Kotlin,
and is build on top of Kotlin’s suspend system
Arrow fx
Notice that raceN(...) returns Either
Arrow optics
Optics are essentially abstractions to update immutable data structures in an elegant way
Lens
A Lens is an optic that can focus into a structure and get, modify, or set its focus (target)
Lenses can be generated for a data class by the @optics
annotation
Λrrow Meta is a meta-programming library that cooperates with the Kotlin compiler in all its phases,
bringing its full power to the community
My experience
- A lot of functionality
- Multiple classes/functions named the same and are placed in different modules
- Can be confusing
- For example raceN
- Other experiences?
- Anyone using arrow in real projects?
- If so, which parts?
Oslo Kotlin Meetup
- Domain Specific Languages - Marie Katrine Ekeberg
- kscript, scripting with Kotlin - Anders Mikkelsen
- Functional programming with Arrow - Jarle Hansen


Thank you for RSVPing! We've got everyone's answers, and it's too late to change them now.
If something has dramatically changed, please email us directly: rsvp@lamp.wedding


Hi, my name is Trevor Dobson, I'm going to tell you a little about myself. I am originally from a small town in Iowa. After high school I attended Iowa State University. After some fun years of living the college life, I graduated with a degree in business. This is when you typically go out and start your career. Not me, this is when I decided to join the Army as an infantryman. During my time in the Army I spent time in Georgia, North Carolina, and Washington. Washington would be where I finally stopped and called it home. I met my wife, deployed to Afghanistan, and then had my daughter who is 4 now. I got out of the Army bounced around a few jobs, couldn’t find anything I enjoyed so I decided to drop everything and learn coding.


{% load sanitize static i18n compress %}
{% trans "Signups are locked (event is old, ongoing or just starting)." %}


cf.Field.compute_vertical_coordinates¶
-
Field.
compute_vertical_coordinates
(default_to_zero=True, strict=True, inplace=False, verbose=None)[source]¶ Compute non-parametric vertical coordinates.
When vertical coordinates are a function of horizontal location as well as parameters which depend on vertical location, they cannot be stored in a vertical dimension coordinate construct. In such cases a parametric vertical dimension coordinate construct is stored and a coordinate reference construct contains the formula for computing the required non-parametric vertical coordinates.
See CF section 4.3.3 “Parametric Vertical Coordinate” and CF
Appendix D “Parametric Vertical Coordinates” for details.
For example, multi-dimensional non-parametric parametric ocean altitude coordinates can be computed from one-dimensional parametric ocean sigma coordinates.
Coordinate reference systems based on parametric vertical coordinates are identified from the coordinate reference constructs and, if possible, the corresponding non-parametric vertical coordinates are computed and stored in a new auxiliary coordinate construct.
If there are no appropriate coordinate reference constructs then the field construct is unchanged.
New in version 3.8.0.
See also
- Parameters
- default_to_zero:
bool
, optional If False then do not assume that missing terms have a value of zero. By default a missing term is assumed to be zero.
- strict:
bool
If False then allow the computation to occur when
A domain ancillary construct has no standard name, but the corresponding term has a standard name that is prescribed
When the computed standard name can not be found by inference from the standard names of the domain ancillary constructs, nor from the
computed_standard_name
parameter of the relevant coordinate reference construct.
By default an exception is raised in these cases.
If a domain ancillary construct does have a standard name, but one that is inconsistent with any prescribed standard names, then an exception is raised regardless of the value of strict.
- inplace:
bool
, optional If True then do the operation in-place and return
None
.- verbose:
int
orstr
orNone
, optional If an integer from
-1
to3
, or an equivalent string equal ignoring case to one of:'DISABLE'
(0
)'WARNING'
(1
)'INFO'
(2
)'DETAIL'
(3
)'DEBUG'
(-1
)
set for the duration of the method call only as the minimum cut-off for the verboseness level of displayed output (log) messages, regardless of the globally-configured
cf.log_level
. Note that increasing numerical value corresponds to increasing verbosity, with the exception of-1
as a special case of maximal and extreme verbosity.Otherwise, if
None
(the default value), output messages will be shown according to the value of thecf.log_level
setting.Overall, the higher a non-negative integer or equivalent string that is set (up to a maximum of
3
/'DETAIL'
) for increasing verbosity, the more description that is printed to convey information about the operation.
- default_to_zero:
- Returns
Examples
>>> f = cf.example_field(1) >>> print(f) Field: air_temperature (ncvar%ta) --------------------------------- Data : air_temperature(atmosphere_hybrid_height_coordinate(1), grid_latitude(10), grid_longitude(9)) K Cell methods : grid_latitude(10): grid_longitude(9): mean where land (interval: 0.1 degrees) time(1): maximum Field ancils : air_temperature standard_error(grid_latitude(10), grid_longitude(9)) = [[0.76, ..., 0.32]] K Dimension coords: atmosphere_hybrid_height_coordinate(1) = [1.5] : grid_latitude(10) = [2.2, ..., -1.76] degrees : grid_longitude(9) = [-4.7, ..., -1.18] degrees : time(1) = [2019-01-01 00:00:00] Auxiliary coords: latitude(grid_latitude(10), grid_longitude(9)) = [[53.941, ..., 50.225]] degrees_N : longitude(grid_longitude(9), grid_latitude(10)) = [[2.004, ..., 8.156]] degrees_E : long_name=Grid latitude name(grid_latitude(10)) = [--, ..., kappa] Cell measures : measure:area(grid_longitude(9), grid_latitude(10)) = [[2391.9657, ..., 2392.6009]] km2 Coord references: grid_mapping_name:rotated_latitude_longitude : standard_name:atmosphere_hybrid_height_coordinate Domain ancils : ncvar%a(atmosphere_hybrid_height_coordinate(1)) = [10.0] m : ncvar%b(atmosphere_hybrid_height_coordinate(1)) = [20.0] : surface_altitude(grid_latitude(10), grid_longitude(9)) = [[0.0, ..., 270.0]] m >>> print(f.auxiliary_coordinate('altitude', default=None)) None >>> g = f.compute_vertical_coordinates() >>> print(g.auxiliary_coordinates) Constructs: {'auxiliarycoordinate0': <CF AuxiliaryCoordinate: latitude(10, 9) degrees_N>, 'auxiliarycoordinate1': <CF AuxiliaryCoordinate: longitude(9, 10) degrees_E>, 'auxiliarycoordinate2': <CF AuxiliaryCoordinate: long_name=Grid latitude name(10) >, 'auxiliarycoordinate3': <CF AuxiliaryCoordinate: altitude(1, 10, 9) m>} >>> g.auxiliary_coordinate('altitude').dump() Auxiliary coordinate: altitude long_name = 'Computed from parametric atmosphere_hybrid_height_coordinate vertical coordinates' standard_name = 'altitude' units = 'm' Data(1, 10, 9) = [[[10.0, ..., 5410.0]]] m Bounds:units = 'm' Bounds:Data(1, 10, 9, 2) = [[[[5.0, ..., 5415.0]]]] m


Secret Family Recipes
Secret Family Recipes was started to solve a simple quandary:
“How do I keep all of my family’s recipes together?”
Not to mention, how do I keep from losing my recipes if I go over to cook at someone else's house? Call me a klutz but I forget things everywhere — getting older does have its drawbacks.
Enter Secret Family Recipes. With this app I can go anywhere and look up my recipes on my phone or through a computer — I no longer need to carry them around with me. I can share them with other family members by sending it to them in the app.
We hope you like this app as much as we do.
All the Best,
The Secret Family Recipe Team


[gecode-users] Fedora packaging Gecode
Julian C. Dunn
jdunn at aquezada.com
Wed Aug 22 04:53:30 CEST 2012
All:
I am working on packaging Gecode into Fedora Linux. During the review process, my reviewer pointed out this problem with Gecode:
---
gecode.x86_64: W: shared-lib-calls-exit /usr/lib64/libgecodegist.so.32.0 exit at GLIBC_2.2.5
This library package calls exit() or _exit(), probably in a non-fork()
context. Doing so from a library is strongly discouraged - when a library
function calls exit(), it prevents the calling program from handling the
error, reporting it to the user, closing files properly, and cleaning up any
state that the program has. It is preferred for the library to return an
actual error code and let the calling program decide how to handle the
situation.
---
While they told me that this is not a blocker to inclusion in Fedora, they advised me to inform upstream (you) such that you might consider fixing it. Could you give me some feedback about that so I can append it to the review request?
- Julian
More information about the users
mailing list


{% comment %}
This is the generic picture module to show pictures and it's caption.
required:
- picture_scaled_url, set the scaled (non retina) image url
- picture_url, sets the image url
optional:
- picture_name, sets the alt text
- picture_caption, sets the caption
- picture_default_alt_text, sets the alternative text
- attributes, additional attributes for the tag
{% endcomment %}
{% load i18n %}


Web App – Simple Interest Calculator
Amount
No. of Years
1
2
3
4
5
6
7
8
9
10
Interest rate :
Compute interest


In the Blues
Posted on Tue 17 January 2017 in Learning
IBM® Bluemix®
A cloud computing platform that combines platform as a service (PaaS) with infrastructure as a service (IaaS).
-
Polyglot (using several languages) programming approaches.
-
No investment in Hardware Models, all is handled.
You can take an idea from
inception, to development sandbox, to a globally distributed production environment
-
IBM® Bluemix® also provides flexible deployment.
-
Provision IBM® Bluemix® resources on-premises, in dedicated private cloud environments, or in the public cloud, and manage the resources from all three types of environments in a single dashboard.
-
All IBM cloud resources that are deployed in public and dedicated environments are hosted from your choice of IBM® Cloud Data Center locations around the world.
-
IBM Cloud Data Centers provide regional redundancy, a global network backbone connecting all data centers and points of presence, and stringent security controls and reporting.
IBM enables you to:
-
Secure Data Centers
-
Test and adopt to a broad range of services.
-
Connect to all of your legacy systems and apps from a single, scalable, cloud platform through private network and API capabilities.
App Dashboard has everything.
Boiler Plates :
Bluemix provides various boilerplates and runtimes:
A boilerplate is a template for an application and its associated runtime environment and predefined services for a specific domain.
A runtime is the set of resources that is used to run an app, provided as containers for different types of apps.
Methods :
Bluemix provides various ways for you to run your apps, for example :
- Cloud Foundry and IBM® Bluemix® Container Service. (run Docker containers on cloud)
Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries – anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.
- You can use IBM® Bluemix® OpenWhisk for distributed, event-driven computing.
OpenWhisk runs application logic in response to events or direct invocations from web or mobile apps over HTTP.
- Use Mobile Services
Services
The Services dashboard provides access to the Bluemix services :
-
Fast + Cheap Apps from IBM DevOps services and the Bluemix Garage Method.
-
Blockchain is a peer-to-peer distributed ledger technology for a new generation of transactional applications that establishes trust, accountability, and transparency while streamlining business processes.
-
Watson gives your apps the power of cognitive computing with a full suite of speech, vision, and data APIs.
-
IBM enables you to do more with rich, integrated cloud databases and Data & Analytics services.
-
The IBM Internet of Things service lets your apps communicate with, and consume data that is collected by, your connected devices, sensors, and gateways. Our recipes make it easy to get devices connected to our Internet of Things cloud. Your apps can then use our real-time and REST APIs to communicate with your devices and consume the data you've set them up to collect.
IBM offers a mobile backend infrastructure where you can build multiplatform, native, or hybrid apps while also being able to monitor and test them. You can also enhance your app with analytics, security, user insight, and continuous delivery. Bluemix also provides experimental services that you can try out. To learn about service types and availability, see Bluemix services.
Infrastructure
The Infrastructure dashboard provides various services to fit your cloud infrastructure needs.


Protocols
The following protocols are available globally.
-
An action is a message object send to a
ActionDispatcher
to change a given stateSee also
ActionDispatcher
, for the object which dispatches an actionDeclaration
Swift
public protocol Action
-
Undocumented
See moreDeclaration
Swift
public protocol ControllerContainer
-
Undocumented
See moreDeclaration
Swift
public protocol ControllerDismisser
-
An instance providing a controller for an specific route pattern, routing option, parameter combination if it is responsible for it
See moreDeclaration
Swift
public protocol ControllerProvider
-
Feature represents a distinct funtionality of your application. It will be provided to all FeatureObservers after addition to configure and connect it to your application and your remaining features. Have look at LogicFeature and LogicFeatureObserver for an example.
Declaration
Swift
public protocol Feature
-
Undocumented
See moreDeclaration
Swift
public protocol FeatureObserver
-
Undocumented
See moreDeclaration
Swift
public protocol HasControllerContainer
-
Undocumented
See moreDeclaration
Swift
public protocol PresenterProvider
-
Undocumented
See moreDeclaration
Swift
public protocol RouteResult
-
Undocumented
See moreDeclaration
Swift
public protocol RoutingAwareViewController
-
Undocumented
See moreDeclaration
Swift
public protocol RoutingDelegate
-
An instance observing all controllers that are presented by the wireframe
See moreDeclaration
Swift
public protocol RoutingObserver
-
A message object describing how the view controller presented after routing will be presented
See moreDeclaration
Swift
public protocol RoutingOption
-
An instance providing a routing option, for a specific route pattern and parameter combinition. The default behaviour should preserve a already determined option (currentOption) for this route pattern. But a RoutingOptionProvider can be used to replace a given option with an other option.
See moreDeclaration
Swift
public protocol RoutingOptionProvider
-
An instance responsible for presenting view controllers Presentation is triggerd by the wireframe after resolving a route match.
See moreDeclaration
Swift
public protocol RoutingPresenter
-
Undocumented
See moreDeclaration
Swift
public protocol TopControllerResolver
-
Undocumented
See moreDeclaration
Swift
public protocol Wireframe : ControllerContainer


You are at zang206's GitHub user page.
Zang206's Profile and Repositories at GitHub.com site
I'm a relative reference to a repository file


CakePHP developers will use the PSR-2 coding style guide in addition to the following rules as coding standards.
It is recommended that others developing CakeIngredients follow the same standards.
You can use the CakePHP Code Sniffer to check that your code follows required standards.
No new features should be added, without having their own tests – which should be passed before committing them to the repository.
Please make sure your IDE is set up to “trim right” on whitespaces. There should be no trailing spaces per line.
Most modern IDEs also support an .editorconfig
file. The CakePHP app
skeleton ships with it by default. It already contains best practise defaults.
Four spaces will be used for indentation.
So, indentation should look like this:
// base level
// level 1
// level 2
// level 1
// base level
Or:
$booleanVariable = true;
$stringVariable = 'moose';
if ($booleanVariable) {
echo 'Boolean value is true';
if ($stringVariable === 'moose') {
echo 'We have encountered a moose';
}
}
In cases where you’re using a multi-line function call use the following guidelines:
As an example, instead of using the following formatting:
$matches = array_intersect_key($this->_listeners,
array_flip(preg_grep($matchPattern,
array_keys($this->_listeners), 0)));
Use this instead:
$matches = array_intersect_key(
$this->_listeners,
array_flip(
preg_grep($matchPattern, array_keys($this->_listeners), 0)
)
);
It is recommended to keep lines at approximately 100 characters long for better code readability. Lines must not be longer than 120 characters.
In short:
Control structures are for example “if
”, “for
”, “foreach
”,
“while
”, “switch
” etc. Below, an example with “if
”:
if ((expr_1) || (expr_2)) {
// action_1;
} elseif (!(expr_3) && (expr_4)) {
// action_2;
} else {
// default_action;
}
// wrong = no brackets, badly placed statement
if (expr) statement;
// wrong = no brackets
if (expr)
statement;
// good
if (expr) {
statement;
}
// wrong = inline assignment
if ($variable = Class::function()) {
statement;
}
// good
$variable = Class::function();
if ($variable) {
statement;
}
Ternary operators are permissible when the entire ternary operation fits on one
line. Longer ternaries should be split into if else
statements. Ternary
operators should not ever be nested. Optionally parentheses can be used around
the condition check of the ternary for clarity:
// Good, simple and readable
$variable = isset($options['variable']) ? $options['variable'] : true;
// Nested ternaries are bad
$variable = isset($options['variable']) ? isset($options['othervar']) ? true : false : false;
In template files (.ctp files) developers should use keyword control structures. Keyword control structures are easier to read in complex template files. Control structures can either be contained in a larger PHP block, or in separate PHP tags:
<?php
if ($isAdmin):
echo '
You are the admin user.
';
endif;
?>

The following is also acceptable:

<?php if ($isAdmin): ?>

You are the admin user.

<?php endif; ?>
Always try to be as strict as possible. If a non-strict test is deliberate it might be wise to comment it as such to avoid confusing it for a mistake.
For testing if a variable is null, it is recommended to use a strict check:
if ($value === null) {
// ...
}
The value to check against should be placed on the right side:
// not recommended
if (null === $this->foo()) {
// ...
}
// recommended
if ($this->foo() === null) {
// ...
}
Functions should be called without space between function’s name and starting parenthesis. There should be one space between every parameter of a function call:
$var = foo($bar, $bar2, $bar3);
As you can see above there should be one space on both sides of equals sign (=).
Example of a method definition:
public function someFunction($arg1, $arg2 = '')
{
if (expr) {
statement;
}
return $var;
}
Parameters with a default value, should be placed last in function definition.
Try to make your functions return something, at least true
or false
, so
it can be determined whether the function call was successful:
public function connection($dns, $persistent = false)
{
if (is_array($dns)) {
$dnsInfo = $dns;
} else {
$dnsInfo = BD::parseDNS($dns);
}
if (!($dnsInfo) || !($dnsInfo['phpType'])) {
return $this->addError();
}
return true;
}
There are spaces on both side of the equals sign.
Arguments that expect objects, arrays or callbacks (callable) can be typehinted. We only typehint public methods, though, as typehinting is not cost-free:
/**
* Some method description.
*
* @param \Cake\ORM\Table $table The table class to use.
* @param array $array Some array value.
* @param callable $callback Some callback.
* @param bool $boolean Some boolean value.
*/
public function foo(Table $table, array $array, callable $callback, $boolean)
{
}
Here $table
must be an instance of \Cake\ORM\Table
, $array
must be
an array
and $callback
must be of type callable
(a valid callback).
Note that if you want to allow $array
to be also an instance of
\ArrayObject
you should not typehint as array
accepts only the primitive
type:
/**
* Some method description.
*
* @param array|\ArrayObject $array Some array value.
*/
public function foo($array)
{
}
Method chaining should have multiple methods spread across separate lines, and indented with four spaces:
<EMAIL_ADDRESS><EMAIL_ADDRESS>->subject('A great message')
->send();
All comments should be written in English, and should in a clear way describe the commented block of code.
Comments can include the following phpDocumentor tags:
@version <vector> <description>
format, where version
and description
are mandatory.PhpDoc tags are very much like JavaDoc tags in Java. Tags are only processed if they are the first thing in a DocBlock line, for example:
/**
* Tag example.
*
* @author this tag is parsed, but this @version is ignored
* @version 1.0 this tag is also parsed
*/
/**
* Example of inline phpDoc tags.
*
* This function works hard with foo() to rule the world.
*
* @return void
*/
function bar()
{
}
/**
* Foo function.
*
* @return void
*/
function foo()
{
}
Comment blocks, with the exception of the first block in a file, should always be preceded by a newline.
Variable types for use in DocBlocks:
You can also combine types using the pipe char:
int|bool
For more than two types it is usually best to just use mixed
.
When returning the object itself, e.g. for chaining, one should use $this
instead:
/**
* Foo function.
*
* @return $this
*/
public function foo()
{
return $this;
}
include
, require
, include_once
and require_once
do not have
parentheses:
// wrong = parentheses
require_once('ClassFileName.php');
require_once ($class);
// good = no parentheses
require_once 'ClassFileName.php';
require_once $class;
When including files with classes or libraries, use only and always the require_once function.
Always use long tags (<?php ?>
) instead of short tags (<? ?>
). The short
echo should be used in template files (.ctp) where appropriate.
The short echo should be used in template files in place of <?php echo
. It
should be immediately followed by a single space, the variable or function value
to echo
, a single space, and the php closing tag:
// wrong = semicolon, no spaces
<?=$name;?>
// good = spaces, no semicolon
<?= $name ?>
As of PHP 5.4 the short echo tag (<?=
) is no longer to be consider a ‘short
tag’ is always available regardless of the short_open_tag
ini directive.
Variable names should be as descriptive as possible, but also as short as possible. All variables should start with a lowercase letter, and should be written in camelBack in case of multiple words. Variables referencing objects should in some way associate to the class the variable is an object of. Example:
$user = 'John';
$users = ['John', 'Hans', 'Arne'];
$dispatcher = new Dispatcher();
Use PHP’s public
, protected
and private
keywords for methods and variables.
For all example URL and mail addresses use “example.com”, “example.org” and “example.net”, for example:
The “example.com” domain name has been reserved for this (see RFC 2606) and is recommended for use in documentation or as examples.
File names which do not contain classes should be lowercased and underscored, for example:
long_file_name.php
For casting we use:
Please use (int)$var
instead of intval($var)
and (float)$var
instead
of floatval($var)
when applicable.
Constants should be defined in capital letters:
define('CONSTANT', 1);
If a constant name consists of multiple words, they should be separated by an underscore character, for example:
define('LONG_NAMED_CONSTANT', 2);
While empty()
is an easy to use function, it can mask errors and cause
unintended effects when '0'
and 0
are given. When variables or
properties are already defined, the usage of empty()
is not recommended.
When working with variables, it is better to rely on type-coercion to boolean
instead of empty()
:
function manipulate($var)
{
// Not recommended, $var is already defined in the scope
if (empty($var)) {
// ...
}
// Use boolean type coercion
if (!$var) {
// ...
}
if ($var) {
// ...
}
}
When dealing with defined properties you should favour null
checks over
empty()
/isset()
checks:
class Thing
{
private $property; // Defined
public function readProperty()
{
// Not recommended as the property is defined in the class
if (!isset($this->property)) {
// ...
}
// Recommended
if ($this->property === null) {
}
}
}
When working with arrays, it is better to merge in defaults over using
empty()
checks. By merging in defaults, you can ensure that required keys
are defined:
function doWork(array $array)
{
// Merge defaults to remove need for empty checks.
$array += [
'key' => null,
];
// Not recommended, the key is already set
if (isset($array['key'])) {
// ...
}
// Recommended
if ($array['key'] !== null) {
// ...
}
}


tmlib.datasets.dataset¶
This module helps loading minibatches from corpus for learning LDA
class tmlib.datasets.dataset.Dataset¶
tmlib.datasets.dataset.Dataset(data_path, batch_size, passes=1, shuffle_every=None, vocab_file=None)
Parameters¶
data_path: string, not default
Path of file input (corpus)
batch_size: int
size of mini-batch in each sampling from corpus.
passes: int, default: 1
passes controls how often we train the model on the entire corpus. Another word for passes might be “epochs”. iterations is somewhat technical, but essentially it controls how often we repeat a particular loop over each document. It is important to set the number of “passes” and “iterations” high enough.
For example, if you set passes = 5, assume that batch_size = 100 and size of corpus is 10000 then number of training iterations is 10000/100*5 = 5000
shuffle_every: int, default: None
Because of sampling randomly from corpus, so minibatches in each pass time must be sampled pseudo-randomly. By the way shuffling corpus, we can create the randomize of sampling minibatch.
If you set shuffle_every=2, it means after passing over corpus 2 times, corpus will be shuffled
vocab_file: string, default: None
File vocabulary of corpus
If corpus is raw text format, file vocabulary is non-necessary. Otherwise, if corpus is tf or sq format, user must set it
Attributes¶
batch_size: int
vocab_file: string,
data_path: string, path of formatted file corpus
data_format: DataFormat.TERM_SEQUENCE or DataFormat.TERM_FREQUENCY
output_format: default is DataFormat.TERM_FREQUENCY
format of mini-batch. User change the format by use method set_output_format
passes: int
shuffle_every: int
pass_no: int
numerical order of passes
batch_no_in_pass: int
numerical order of minibatches in each pass
work_path: string
This path is different from data_path. If corpus is shuffled then work_path is path of the shuffled file, not the original file
fp: file pointer of file work_path
end_of_file: boolean,
end_of_data (inheritance attribute)
mini_batch_no (inheritance attribute)
Methods¶
__init__(data_path, batch_size, passes=1, shuffle_every=None, vocab_file=None)
load_mini_batch ()
loading a mini-batch from corpus with specific format (controlled by output_format)
check_end_of_data ()
To check out that whether we visit to the last iteration or not.
Return True if the last mini-batch is loaded
set_output_format (output_format)
set format for the loaded mini-batch
- Parameters: output_format (DataFormat.TERM_SEQUENCE or DataFormat.TERM_FREQUENCY)
get_total_docs ()
Return number of documents which have been analyzed until now
get_num_tokens ()
Return number of words in corpus
get_num_terms ()
Return number of unique terms in corpus (size of vocabulary set)


Android module for record audio in different format like(mp4,3gp) without using intent.
This module needs following permissions
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_INTERNAL_STORAGE" />
Note: These permissions already added in timodule.xml, so no need to add in tiapp.xml
To access this module from JavaScript, you would do the following:
var audioRecorder = require("titutorial.audiorecorder");
The audiorecorder variable is a reference to the Module object.
Based on Android MediaRecorder http://developer.android.com/reference/android/media/MediaRecorder.html
Method to start the audio recording process.
Parameters
audioRecorder.OutputFormat_MPEG_4
or audioRecorder.OutputFormat_THREE_GPP
; default = audioRecorder.OutputFormat_THREE_GPP
audioRecorder.AudioEncoder_AAC
, audioRecorder.AudioEncoder_AMR_NB
, audioRecorder.AudioEncoder_AMR_WB
, audioRecorder.AudioEncoder_DEFAULT
; default = audioRecorder.AudioEncoder_AMR_NB
audio_recorder
Method to check recording process
Method to check amplitude of microphone input
audioRecorder.startRecording({
outputFormat : audioRecorder.OutputFormat_THREE_GPP,
audioEncoder : audioRecorder.AudioEncoder_AMR_NB,
audioEncodingBitRate: 128000,
audioSamplingRate: 44100,
directoryName : "testdir",
fileName : "testfile",
maxFileSize : 7000,
success : function(e) {
alert("success => " + e.filePath);
Ti.API.info("response is => " + JSON.stringify(e));
var audioDir = Titanium.Filesystem.getFile(Titanium.Filesystem.externalStorageDirectory, "testdir");
var audioFile = Ti.Filesystem.getFile(audioDir.resolve(), e.fileName);
Ti.API.info("audioFile.nativePath = " + audioFile.nativePath);
audioPlayer.url = audioFile.nativePath;
},
error : function(d) {
alert("error => " + e.message);
Ti.API.info("error is => " + JSON.stringify(d));
}
});
refer example/app.js for more info
Karthi Ponnusamy -<EMAIL_ADDRESS>Copyright (c) 2013 titaniumtutorial.com
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Creates a new instance of the persistence.
(optional) a persister component that loads and saves data from/to flat file.
Clears component state.
(optional) transaction id to trace execution through call chain.
callback function that receives error or null no errors occured.
Closes component and frees used resources.
(optional) transaction id to trace execution through call chain.
callback function that receives error or null no errors occured.
Configures component by passing configuration parameters.
configuration parameters to be set.
Creates a data item.
an item to be created.
(optional) callback function that receives created item or error.
Deletes data items that match to a given filter.
This method shall be called by a public deleteByFilter method from child class that receives FilterParams and converts them into a filter function.
(optional) transaction id to trace execution through call chain.
(optional) a filter function to filter items.
(optional) callback function that receives error or null for success.
Gets a number of items retrieved by a given filter.
This method shall be called by a public getCountByFilter method from child class that receives FilterParams and converts them into a filter function.
(optional) transaction id to trace execution through call chain.
(optional) a filter function to filter items
callback function that receives a data page or error.
Gets a list of data items retrieved by a given filter and sorted according to sort parameters.
This method shall be called by a public getListByFilter method from child class that receives FilterParams and converts them into a filter function.
(optional) transaction id to trace execution through call chain.
(optional) a filter function to filter items
(optional) sorting parameters
(optional) projection parameters (not used yet)
callback function that receives a data list or error.
Gets a random item from items that match to a given filter.
This method shall be called by a public getOneRandom method from child class that receives FilterParams and converts them into a filter function.
(optional) transaction id to trace execution through call chain.
(optional) a filter function to filter items.
callback function that receives a random item or error.
Gets a page of data items retrieved by a given filter and sorted according to sort parameters.
This method shall be called by a public getPageByFilter method from child class that receives FilterParams and converts them into a filter function.
(optional) transaction id to trace execution through call chain.
(optional) a filter function to filter items
(optional) paging parameters
(optional) sorting parameters
(optional) projection parameters (not used yet)
callback function that receives a data page or error.
Checks if the component is opened.
true if the component has been opened and false otherwise.
Opens the component.
(optional) transaction id to trace execution through call chain.
callback function that receives error or null no errors occured.
Saves items to external data source using configured saver component.
(optional) transaction id to trace execution through call chain.
(optional) callback function that receives error or null for success.
Sets references to dependent components.
references to locate the component dependencies.
Generated using TypeDoc
Abstract persistence component that stores data in flat files and caches them in memory.
This is the most basic persistence component that is only able to store data items of any type. Specific CRUD operations over the data items must be implemented in child classes by accessing this._items property and calling save method.
MemoryPersistence
JsonFilePersister
Configuration parameters
References
*:logger:*:*:1.0
(optional) ILogger components to pass log messagesExample
class MyJsonFilePersistence extends FilePersistence<MyData> { public constructor(path?: string) { super(new JsonPersister(path)); } public getByName(correlationId: string, name: string, callback: (err, item) => void): void { let item = _.find(this._items, (d) => d.name == name); callback(null, item); }); public set(correlatonId: string, item: MyData, callback: (err) => void): void { this._items = _.filter(this._items, (d) => d.name != name); this._items.push(item); this.save(correlationId, callback); } }


dash.games.packages.form.title_help_html
dash.games.packages.form.description_help_html
You must set up your financial information before you can start accepting money.
| Timezone |
{{ promotionalPricing.timezone }}
All times are based off this timezone.
|
|---|---|
| Start | {{ saleStartLocal | amDateFormat:'lll' }} |
| End | {{ saleEndLocal | amDateFormat:'lll' }} |
| Price |
{{ promotionalPricing.amount | gjCurrency }}
{{ ((originalPricing.amount - promotionalPricing.amount) / originalPricing.amount * 100).toFixed( 0 ) }}% off
|
All time selection below will use this timezone.
Should auto-detect, but if it doesn't, choose your closest city.
{{ ((formModel.price - formModel.sale_price) / formModel.price * 100).toFixed( 0 ) }}% off
We use the primary package to determine the price to show on game listings. You can only have one primary package for your game.


Play Framework Primer - Scala Forms
23 Jul 2019This is part 3 of a series about basics of Play framework. In part 2, we covered fundamentals of routing.
In this article, we will cover forms in Play framework. I have personally never seen a functioning web application that does not heavily use forms.
Forms are very key in collecting both simple and complex user input and Play provides very solid support for implementing forms in your application
Concept of Data Binding
Data binding is a general computer programming concept that establishes a two way relationship between two different data presentation formats.
When data changes in one format, it is automatically translated into the other format. In Playframework, these format are the UI format which uses a form and the underlying data in models or case objects.
For data binding to happen in Play, there is a library that takes data from a post request, looks for formatted values and bands to a Form object then populates a case object/model.
Dependencies
Playframework bundles some form handling utilities in the play.api.data
package.
play.api.data
package and what is thereplay.api.data.Forms._
package and what is there- validation and constraints in
play.api.data.validation.Constraints._
Form handling basics
Introduction
In this section, we will go through the steps of building a simple web application to add users to a list in Playframework that demonstrates the basics of form handling.
Form handling involves form definition, defining constraints as well as validating data against these constraints, displaying the bound form in view templates as well as populating post data in case classes and finally, processing form results/errors in a view template.
We will cover many of these concepts in this article.
First let’s create a new web application using the instructions in this article by running:
when we run the application, we should see Welcome to Play!
when we visit http://localhost:9000
.
We may encounter some new terms and maybe new and confusing concepts here but feel free to ignore these for now or visit the official docs to get a better idea.
Let’s first create the models directory/package as app/models
as the template may have come with only app/controllers
and app/views
. You can do this using intelliJ or the IDE you use.
Form Definition
Let’s also change the name of the controller from HomeController
to FormController
for consistency with the article, make the appropriate change in the route:
Create app/models/User
model to hold data in the code:
Add these important imports which form handling depends on:
Define a form object in the controller. The form object is a scala object that creates a new form from a mapping(map of field name to data type).
It also takes apply
and unapply
methods, luckily for us, we can use the same for User
since it’s a case class:
With the above step, we have nearly completed one leg of data binding, the next leg is on the UI, it involves enabling the index.scala.html
view tempate to display the form.
Showing the form in a view template
To do this, we need a little bit of information about how view templates work, specifically the fact that they use a combination of a scala variant(with @
directives) and html. They take parameters from the controller.
Take a look at how the view template currently looks:
The first line has parentheses prefixed with the @
directive and this is where we inject scala params. The first mandatory param is the form object, empty in this case.
we can have multiple parameters in a view template just like in an ordinary scala method. So we will also add a param containing a list of users from the server, so list and form will be in the same view template for simplicity:
As you may have noticed, we have added a second param list which has an implicit parameter: messages. Don’t worry about this for now, we will cover it shortly.
Play provides a suite of helpers for form handling in a view template. This way, we can use scala to create form elements equivalent to html, starting with the form
tag as well as all available form elements like input
, checkbox
, radio
buttons etc.
We are also able to add other html attributes just like in an html form. So let’s provide the view template with what it needs to create a form to collect user input for the User
model as well as a list (ul
) tag to list users:
Notice the minor changes to the headers for consistency with what our page is doing.
The reason we injected Messages
is that the form helpers e.g. input
, checkbox
all take a message provider as an implicit param. This is because they need to provide error messages mapped to the language defined in the request. This is part of play’s internationalization capability.
Message processing in FormController
Back to FormController
, we need to make few more changes to complete it. First, let’s modify the controller to make it a real form controller, with the appropriate changes to enable it handle data exchange with the view template.
Inject a MessagesActionBuilder
in the controller and let it extend AbstractController
instead of BaseController
and provide the default injected ControllerComponents
as a param to AbstractController
.
Also, each action handling forms will return the instance of MessagesActionBuilder
we injected in the controller as well as take an implicit MessagesRequest
instance instead of a Request
instance.
We have now amended the view template in the action response and added the parameters we defined earlier. Phew!!!
The last 2 paragraphs are really dense and so much information to process, the summary is that form processing needs to be language aware and the components we have injected, broadyly speaking, expose a messages API that taps into Play’s internationalization capability.
Processing POST request in Controller
We need to create another controller action to process the POST
request from the form and add the new user into an in memory database, we will just use a ListBuffer
which is a mutable scala list:
We are using the bindFromRequest
convenience method of the form object which binds it to the post data. We then process the result using the fold
method that takes 2 parameters for how to handle both the error case where the form fails to bind and the success case where data binding successed.
Finally, the controller looks like this:
Routing requests to controller
To complete the implementation, we will add the POST
route in the routes file:
We have applied a modifier +nocsrf
to the route to by pass the protective check for a csrf
token in the request.
Testing
We can test the application by visiting https://localhost:9000
. We should be able to add users in the form and when submitted, should be displayed in the user list section.
The page should be looking like this:
Conclusion
In this article, we have explored basics of forms in Play framework by building a working list application. There may have been several new concepts and things that don’t make sense.
I hope the aspect of building a complete app can act as a starting point to explore more about forms from the official documentation. The complete source code is available on github


|
Bullet Collision Detection & Physics Library
|
btShapeHull implemented by John McCutchan. More...
#include <btShapeHull.h>
Public Member Functions | |
| BT_DECLARE_ALIGNED_ALLOCATOR () | |
| btShapeHull (const btConvexShape *shape) | |
| ~btShapeHull () | |
| bool | buildHull (btScalar margin, int highres=0) |
| int | numTriangles () const |
| int | numVertices () const |
| int | numIndices () const |
| const btVector3 * | getVertexPointer () const |
| const unsigned int * | getIndexPointer () const |
Static Protected Member Functions | |
| static btVector3 * | getUnitSpherePoints (int highres=0) |
Protected Attributes | |
| btAlignedObjectArray< btVector3 > | m_vertices |
| btAlignedObjectArray< unsigned int > | m_indices |
| unsigned int | m_numIndices |
| const btConvexShape * | m_shape |
btShapeHull implemented by John McCutchan.
The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices. It can be useful for to simplify a complex convex object and for visualization of a non-polyhedral convex object. It approximates the convex hull using the supporting vertex of 42 directions.
Definition at line 27 of file btShapeHull.h.
| btShapeHull::btShapeHull | ( | const btConvexShape * | shape | ) |
Definition at line 24 of file btShapeHull.cpp.
| btShapeHull::~btShapeHull | ( | ) |
Definition at line 32 of file btShapeHull.cpp.
| btShapeHull::BT_DECLARE_ALIGNED_ALLOCATOR | ( | ) |
| bool btShapeHull::buildHull | ( | btScalar | margin, |
| int | highres = 0 |
||
| ) |
Definition at line 38 of file btShapeHull.cpp.
|
inline |
Definition at line 54 of file btShapeHull.h.
|
staticprotected |
Definition at line 113 of file btShapeHull.cpp.
|
inline |
Definition at line 50 of file btShapeHull.h.
| int btShapeHull::numIndices | ( | ) | const |
Definition at line 108 of file btShapeHull.cpp.
| int btShapeHull::numTriangles | ( | ) | const |
Definition at line 98 of file btShapeHull.cpp.
| int btShapeHull::numVertices | ( | ) | const |
Definition at line 103 of file btShapeHull.cpp.
|
protected |
Definition at line 32 of file btShapeHull.h.
|
protected |
Definition at line 33 of file btShapeHull.h.
|
protected |
Definition at line 34 of file btShapeHull.h.
|
protected |
Definition at line 31 of file btShapeHull.h.


Below is the information for user {{ user.username }} that has asked validation.
| Full name | {{ user.username }} |
| User number (UserX) | {{ user.userx }} |
| Cluster name | {{ user.clustername }} |
| Cluster IP | {{ user.clusterip }} |
| Prism Central IP | {{ user.pc_ip }} |
Please make sure the user has the following created for the validation
{% if val_name=="cont" %}
Open in a web browser http://{{ user.docker_vm_ip }}:5000/products
You should see something like this screen:
Open in a web browser http://{{ user.docker_vm_ip }}:8080
Use for the login in Gitea: nutanix with password nutanix/4u (If not working, please ask {{ user.username }} for the credentials via Slack).
You should see something like this screen:
Open in a web browser http://{{ user.docker_vm_ip }}:5050/products
You should see something like this screen:
If you agree that the user can be validated, please click the I validate button


You must be using
Google Chrome
as browser to participate in this experiment.
The detected browser was not Google Chrome. Click the button below go back to prolific and return your submission to avoid penalties.


'2001: A Space Odyssey' (1968)
A retrospective movie review by Walter Frith
Member of the 'Internet Movie Critics Association' http://www.geocities.com/Hollywood/Studio/5713/index.html
and
Member of the 'Online Film Critics Society' http://ofcs.org/ofcs/
I don't think any one director's film stands out as clearly as his or her masterpiece as '2001: A Space Odyssey' does for Stanley Kubrick. Amazingly, in my opinion, the film doesn't look dated at all. On DVD, the clarity, colour, resolution and overall presentation have held up remarkably well. It's the kind of film that contains hypnotic elements directly intended to stir any imagination and conjure up debate contained in its religious overtones. It's also the kind of film that means different things to different people. The entertainment value of it's beginning, middle and ending depend entirely on your views of evolution vs. creationism.
In 1989's 'Field of Dreams', Ray Kinsella (Kevin Costner) observes while speaking to Terence Mann (James Earl Jones) that he once read a passage he wrote that speaks of all the cosmic tumblers of the universe falling into place and for a brief moment the universe opens up to show you what's possible. This was never more true than for the film '2001: A Space Odyssey', as it is a film far ahead of its time and when it was released in 1968, it kept in line with director Stanley Kubrick's central theme of technology running amok.
Failing to earn a Best Picture Oscar nomination, '2001: A Space Odyssey' did get nominations for Kubrick as Best Director, Best Screenplay, based on the work of author Arthur C. Clarke's 'The Sentinel'. Clarke co-wrote the screenplay with Kubrick. The film received additional Oscar nominations for its sets and Kubrick won an Oscar for creating, supervising and executing the film's tremendously revolutionary visual effects.
Beginning in prehistoric times with what the film's opening caption puts forward as 'The Dawn of Man', apes move around on a huge open wasteland and display the barbaric attributes that would remain intact as evolution would eventually make them humans. A group of the beasts awaken one morning to find a a large rectangular black slab among the natural landscape of desert rock. The primates are astonished by its remarkably smooth texture and divine construction, perhaps it served as a stepping stone (no pun intended) for mankind's progress in the things he later invented. Perhaps the wheel, the printing press and other forms of ancient technology could be derived from this. The large rectangular black slab is known as the monolith. The monolith appears later in the film and its purpose remains a mystery.
>From a slow motion shot of a primate throwing a bone in the air, the film cuts to a time we now know as being near to the 21st century as a space craft in the similar shape of the bone travels through outer space and we are treated to some wonderful classical music by Strauss as we gaze in splendor at Kubrick's fantastic visual style.
The monolith appears again in 1999 on the moon near the Sea of Tranquility as an expedition team of American astronauts finds it and the monolith omits an eerie ringing to deafen all who come into contact with it.
Next is the Jupiter mission in the year 2001. Astronauts David Bowman (Keir Dullea) and Frank Poole (Gary Lockwood) lead an expedition team aboard the spacecraft Discovery. They are seen as the rest of the crew is in hibernation for the long trip. The computer overseeing the mission is HAL 9000. I noticed that the three letters after H, A and L are I, B and M. Coincidence? Who knows? Seems clever to me. HAL 9000 is voiced by actor Douglas Rain who has an eerie emptiness in his voice, making HAL a most chilling character and the best developed one in the movie, even more so than his human counter parts.
As the mission proceeds there is an apparent malfunction by the HAL 9000 computer and this leads to the beginning of the film's stunning climax where silence is used as powerfully as any loud, expensive action film where the noise is deafening. This is the film's greatest asset. The terror of being alone in space where the silence is extremely loud to the human condition is felt as clearly as actually being in the film.
The term 'Space Odyssey' pertains mostly to the film's last half hour as astronaut Bowman is transported to a part of the universe not only unexplored by man but unimagined as well. The mansion style surroundings contained in the film's lavish conclusion where a bedroom, bathroom and dining room are seen by Bowman observing his own origins and future lend suspicions that mankind's origins have an outer space connection which is a theory put forward by many scientists.
I must confess that I am not a student of literature. I don't read books. When I observe a film, I judge it only on its own merits and any comparisons I may draw to its literary origins are based on what I've heard and researched. One thing I didn't like about the sequel to '2001: A Space Odyssey' entitled '2010: The Year We Make Contact' is the explanation of why the HAL 9000 computer failed. The computer was apparently told of the true nature of the mission and instructed not to reveal anything to Bowman or Poole so when HAL was questioned by the astronauts in the original film, he became trapped and not having the human capacity to lie, he malfunctioned. This seems like a cop out to the original film's theme of technology running amok as I mentioned in the second paragraph as '2010' explains that human meddling caused HAL to malfunction rather than HAL malfunctioning on his own.
'2001: A Space Odyssey' is a marvel of film making not for what it does but for what it doesn't do. It doesn't try to be a film with a formula, primary character development or scathing amounts of dialogue. There is in fact, very little dialogue in its running time of nearly two and a half hours and Stanley Kubrick's intention is to leave his audience with something to take home in their minds and reflect upon it as not only a work of art but as an experience designed to push the full limits of the human imagination.
Visit FILM FOLLOW-UP by Walter Frith http://home.netinc.ca/~wfrith/movies.htm
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Conference tracks
SciPyLA 2017 is the 5th Latin American conference on the applications in science of the Python programing language.
The SciPyLA conference encourages submissions of three types of papers:
Research and position papers: We encourage papers that describe work-in-progress or recently completed work based on the themes and goals of the different tracks or related topics, report on experiences gained, question accepted wisdom, raise challenging open problems, or propose speculative new approaches. We will accept two types of papers: research papers up to 15 pages in length; and position papers up to 4 pages in length.
Hypotheses papers: Hypotheses papers explicitly identify beliefs of the research community or mainstream industries about how a scientific technology and tools affect research practice. Hypotheses can be collected from mailing lists, blog posts, paper introductions, developer forums, or interviews. Papers should clearly document the source(s) of each hypothesis and discuss the importance, use, and relevance of the hypotheses on research or practice. Papers may also, but are not required to, review evidence for or against the hypotheses identified. Hypotheses papers can be up to 4 pages in length.
- Review articles: Review articles summarize the current state of understanding on a topic. A review article surveys and summarizes previously published studies, rather than reporting new facts or analysis. The conference encourages submission of industrial experience and tool demonstrations in this category. Review articles can be up to 10 pages in length. Review Articles teach about:
- the main people working in a field
- recent major advances and discoveries
- significant gaps in the research
- current debates
ideas of where research might go next
Research papers will be judged for technical novelty and scientific merit. Any previous publication in any form must be explicitly identified and cited on the first page of the submission. Papers in all other categories will be judged on novelty, clarity, accessibility, and suitability for a high quality presentation and discussion at the workshop.
Submissions may be accompanied by data papers and video papers complementing the subjects discussed.
The activities scheduled in SciPyLA 2017 program are the following.
Topics
Some particular areas of interest are:
- Biological Inspired Sensors. APIs
- Bio-printing
- Bioplastic
- Brain, Heart and Organ Simulations and Processing
- Brain reading and Neuroinformatics
- Brain-computer interfaces
- Cancer and Tumor Studies with Big Data
- Conductive polymers
- DNA Sequencing
- Health Informatics as a Service (HIaaS)
- Immunoassays
- In vitro meat
- Lab-on-a-chip and applications
- Nanomedicines and Nanosensors
- Oncolytic virus research
- Personalized treatments
- Plantibodies
- Stem cell treatments
- Synthetic Biology Open Language
- Tissue engineering
In general the program committee will accept paper submissions related to the following disciplines:
Analytical Chemistry, Astrobiology, Biochemistry, Bioinformatics, Biomaterials, Biomechatronics, Biophysics, Biotechnology, Chemical Engineering, Chemical Biology, Cheminformatics, Computational Biology, Computational Chemistry, Femtochemistry, Flow Chemistry, Genetics, Genomics, Healthcare Science, Immunochemistry, Immunology, Mathematical Biology, Mathematical Chemistry, Microbiology, Molecular Biology, Molecular Mechanics, Nanomaterials, Nanotechnology, Neuroscience, Paleobiology, Polymer Chemistry and Engineering, Phytochemistry, Structural Biology, Supramolecular Chemistry, Synthetic Biology, Synthetic Genomics Systematics, Tissue Engineering, Virology.
Latin American Workshop on Python and Physics
Topics
Some particular areas of interest are:
- Numerical methods for resolution of differential equations
- High-energy physics experiments
In general the program committee will accept paper submissions related to the following disciplines:
Applied Physics, Astronomy, Astrophysics, Computational Physics, Elementary Particle Physics, Experimental Physics, Fluid Dynamics, Mathematical Physics, Molecular Quantum Mechanics, Nuclear Physics, Numerical Simulations, Physics of materials, Quantum Physics, Radiochemistry, Semiconductors, Statistical Mechanics.
Latin American Workshop on Python and Electrical Engineering
Topics
Some particular areas of interest are:
- 3D printing
- 3D and holographic display solutions
- Adaptive Signal Processing and Control
- Agricultural robots
- Android, gynoid
- Autonomous vehicles
- Bionics
- Claytronics algorithms and programming
- Cloud robotics
- Collective Adaptive Systems
- Computer-based Manufacturing Technologies
- Computer-generated holography devices
- Digital scent technology
- Electric vehicles
- Energy-efficient networking and smart grid technologies
- Expert Systems for Industry
- Flying cars
- Future-generation sensor networks
- Hardware prototyping and simulation
- Human-robots Interfaces
- Intelligent Fault Detection and Identification
- Machine Learning in Control Applications
- MyHDL
- Petri Nets (System Design/Verification with Nets, Protocols and Networks)
- Powered exoskeleton
- Real-time systems
- Robot Design, Development and Control
- Robotic surgery
- Self-reconfiguring modular robots
- Self-organization, self-stabilization, & autonomic computing
- System-on-Chip design and simulation
- Software Agents for Intelligent Control Systems
- Vehicular communication systems
- Virtual prototyping and testing of cyber-physical systems
- Wearable devices
In general the program committee will accept paper submissions related to the following disciplines:
Aerospace Engineering, Artificial Intelligence, Control Systems and Theory, Electronics, Electronic Design Automation, Electronic materials and Devices, Hardware Design, High-Performance Computing, Magnetic Materials and Devices, Mechatronics, Optical materials and devices, Robotics, Semiconductors.
Latin American Workshop on Python, Economics and Management Science
Topics
Some particular areas of interest are:
- Airport simulation
- Business Intelligence
- Business Process as a Service (BPaaS)
- Business Process Modeling
- CRM, ERP and Decision Support Systems
- Cryptocurrency
- Forecasting
- E-Business, E-Entrepreneurship, E-Learning, and E-Logistics
- Economics of big data
- Enterprise and Strategic Information Systems
- Enterprise Service Bus, Workflows, Data and Tool Integration
- Financial Software as a Service (FSaaS)
- Integrated Production, Inventory and Distribution planning
- Lean Enterprise, Lean Startups
- Lot Sizing and Scheduling
- Merchandise port and Shipping transport simulation
- Mobile payment protocols, solutions, service systems, platforms and marketplaces
- Network economics
- Payment gateways
- Physical internet
- Process Mining and Process Reengineering
- Process simulation frameworks
- Public transport simulation
- Sharing economy
- Simulation for business planning
- Simulation and models in finance
- Simulation in warehouse operations
- Simulation to predict market behavior
- Simulation-based scheduling
- Social web economics and business
- Stochastic Processes
- Supply Chain Information Systems
- Virtual Enterprises and Interoperability
In general the program committee will accept paper submissions related to the following disciplines:
Advertising, Complexity Economics, Computational Economics, Computational Finance, Combinatorial Optimization, E-Business, Econometrics, Experimental Economics, Financial econometrics, Large Scale Optimization, Logistics, Marketing, Macroeconomics, Mathematical Economics, Microeconomics, Operations management, Suply chain management.
Latin American Workshop on Python and Emerging Computing Technologies
A number of research subjects are pushing the limits of current technologies and tools. It is then convenient to explore the impact of Python to support the most prominent ongoing developments, advances, and innovations in various fields of modern technology which rely extensively on complex computing systems. Submitted contributions are expected to portray how Python constitutes an integral part of the technical innovations and the particular role of the programming language in providing a competitive advantage.
Topics
Some particular areas of interest are:
- 4G and 5G cellular communications
- Agent-based systems and architectures
- Agent-to-Human service interactions
- Analytics as a Service (AaaS)
- Augmented reality
- Big Data
- Cloud Computing, IaaS, PaaS and SaaS
- Big Data as a Service (BDaaS)
- Biometrics
- Combinatorial optimization
- Computational Geometry
- Computer-generated imagery
- Computer vision
- Data Mining
- Data-parallel algorithms and SIMD architectures
- Data Science
- Distributed algorithms, operating systems, and database systems
- Domain Specific Languages
- Deep learning
- Evolutionary computation
- Graph Computation Models
- High-performance Computing
- Image processing
- Integration as a Service
- Internet of Things
- Large scale optimization
- Machine learning
- Machine to Machine Communications
- Mobile collaboration and e-learning
- Mobile database retrieval techniques, transaction models and caching techniques
- Network function virtualization and Mobile edge computing
- Scalable Model-Driven Engineering
- Pattern recognition
- Radio-frequency identification
- Software Defined (and Cognitive) Networks
- Software Defined Radio
- Speech recognition
- Virtual reality
- Virtualization and Containers
- Wearable solutions
In general the program committee will accept paper submissions related to the following disciplines:
Artificial Intelligence, Business Intelligence, Cryptgraphy, Data Science, Datawarehousing, Digital Broadcasting Networks, Digital Signal Processing, Mass media, Optical fiber networks, Quantum Computing, Telecommunications, Wireless Technologies.
Latin American Workshop on Python and Earth Sciences
Topics
Some particular areas of interest are:
- Atmospheric carbon dioxide removal
- Carbon neutral fuel
- Climate and weather-related simulations
- Closed ecological systems
- Natural Science as a Service (NSaaS)
- Precision agriculture
- Simulation for disaster mitigation
- Vertical farming
- Weather Data Visualization
- Weather Forecasting
In general the program committee will accept paper submissions related to the following disciplines:
Astronomy, Astrophysics, Atmospheric Chemistry, Ecotechnology, Edaphology, Gemology, Geochemistry, Geodesy, Geography, Geology, Geomorphology, Geophysics, Glaciology, Hydrogeology, Hidrology, Inorganic Chemistry, Marine Chemistry, Meteorology, Mineralogy, Oceanography, Paleontology, Pedology, Petrochemistry, Soil Science, Speleology.
Latin American Workshop on Python, Social Sciences and Humanities
Topics
Some particular areas of interest are:
- Adaptive/Personalized conversational media
- Ambient intelligent frameworks, platforms, and systems
- Arcology
- Autonomous building
- Bionic architecture
- Civic technology and Smart cities. Examples and Case Studies
- Computational intelligence for media adaptation and personalization
- Content creation, annotation and modelling for semantic and social web
- Context-aware multimedia applications
- Domed city
- e-Communities
- Education as a Service (EaaS)
- Machine translation
- Multilingual content navigation
- Online social models for social networking and consumption simulation
- Ontologies and reasoning applied to social media
- Open data: Issues, Services and Solutions
- Privacy/Security issues in Social and Personalized Media Applications
- Semantic context modelling and extraction
- Semantic web technologies
- Semantics-based recommender systems: theory and applications
- Semantics-driven indexing and retrieval of multimedia contents
- Sharing economy
- Simulation of building physics
- Simulation of urban mobility
- Social and semantic media collaboration platforms (e.g. semantic wikis)
- Social multimedia applications (livecasting, audio-video sharing)
- Social multimedia tagging and multimedia content communities
- Social network aggregation
- User modelling and dynamic profiling
- User-generated content mechanisms
- Video Search and Video Mining
In general the program committee will accept paper submissions related to the following disciplines:
Architecture, Bibliometrics, Citation analysis, Computational Linguistics, Computational Sociology, Internet sociology, Journalism, Mass media, Natural language processing, Sociocybernetics, Urban planning, Urban sociology.


---
layout: post
title: "Chef Grant Achatz cancer free"
---
Earlier this year Chef Grant Achatz of the fabulous Chicago restaurant Alinea was diagnosed with tongue cancer, shocking foodies and his contemporaries across the world. Happily, Chef Achatz and his family has received an early Christmas gift in the form of his cancer going into remission, the news coming from a statement from the talented chef.
I wish him, his family and all you fine folks happiness and health.
Achatz Update: Cancer Free


This is a system that can deal with bookings for rooms in Edinburgh, Glasgow and London. It will calculate a price based on how long someone is staying at the hotel. It then saves this data to a CSV file so you can check reservations at another time.


#include <runner.hh>
|
| static bool | exists (int64_t pid) |
| | Check if a given process is running. More...
|
| |
◆ runner() [1/2]
| osapi::process::runner::runner |
( |
int64_t |
pid | ) |
|
Class constructor.
- Parameters
-
| [in] | pid | - The process ID that the runner will represent |
◆ runner() [2/2]
| osapi::process::runner::runner |
( |
| ) |
|
◆ ~runner()
| osapi::process::runner::~runner |
( |
| ) |
|
◆ exists()
| bool osapi::process::runner::exists |
( |
int64_t |
pid | ) |
|
|
static |
Check if a given process is running.
- Parameters
-
- Returns
- True if the process exists. False otherwise.
◆ getParentPID()
| int64_t osapi::process::runner::getParentPID |
( |
void |
| ) |
|
Obtain the parent process ID of the runner instance.
- Returns
- Parent Process ID
◆ getPID()
| int64_t osapi::process::runner::getPID |
( |
void |
| ) |
|
Get the process ID of the runner instance.
- Returns
- Runner Process ID
◆ getState()
| state osapi::process::runner::getState |
( |
void |
| ) |
|
Get the state of an existing process.
- Returns
- Process State
◆ getStatus()
| status osapi::process::runner::getStatus |
( |
void |
| ) |
|
Get the status of an existing process.
- Returns
- Process status
◆ terminate()
| bool osapi::process::runner::terminate |
( |
size_t |
graceTime | ) |
|
Terminate a process.
- Parameters
-
| [in] | graceTime | - The grace time between attempting a normal termination and a forced one. |
- Returns
- True if the process was terminated, false otherwise
◆ id
The documentation for this class was generated from the following files:


MapMan is a unique puzzle game for all ages. As you work your way through each of the 100 levels you will encounter special tiles which will challenge you to think quickly, think laterally, tilt the wrong way round, tilt the right way round, remember tiles that disappear, predict where MapMan will reappear, avoid poisonous tiles and above all else get to the exit within 20 seconds.
MapMan was coded on an iPhone using the amazing Pythonista. In order to submit MapMan to the App Store it was built on a MacBook Air using the nifty Pythonista App Template. We collaborated using Slack and shared files using DropBox. We got lots of help from the friendly folks on the Pythonista Forum. Read more about the MapMan story on our blog.
Tilt yout device to move MapMan around the maze, you have twenty seconds to reach the exit. Along the way you will encounter various special tiles which add to the challenge.
CloseThe reverse tile flips the tilt controls i.e. left=right, down=up and vice-versa. Can you get to the exit before the time runs out?
ClosePick your route, which way is fastest?
CloseThe closed eye hides tiles while the open eye shows them. Take a good look so you remember where the tiles are.
CloseEven when they are hidden, you can still step on tiles. Where were they again?
CloseRound and round and round we go, what tiles are hidden? Step on the eye to show.
Close


A security alarm app for bicycle
Bike Alarm from Jared Odulio on Vimeo.
There are about 1,600,000 bicycle owners in the states of California and Oregon that owns a smartphone either an Android or an iPhone. all this 1,600,000 bicycle owners in the given states has Facebook or Twitter accounts and using their bicycles for commuting, sports or other recreation. 18% of bicycle theft in U.S. happens in these states though it may be higher due to underreporting since bike theft is considered petty crime and is generalized. This is the target demographic of the Bicycle Security Alarm App and most security alarm apps in Google Play and App Store has universal purpose and inadequately serve this market.
The app will sound off an alarm when bicycle (provided the phone is attached to bicycle) is moved from its place by an unauthorized person (the guy who don't know how to disarm the alarm) and will provide GPS location and alert police etc via SMS.
{{> location}}
BikeAlarm is a security alarm app for bicycle created by Advanced Idea Mekanix.
By downloading this app the user agrees to the Terms Of Use of this application.
This application will:
Access your device’s phonebook
Send SMS messages charged to the user by the carrier
Access the internet through the mobile network (3G, 4G, etc.) where data charges will be applied
to the user by the carrier
Access the device storage media (phone and SD card)