See: Description
| Interface | Description |
|---|---|
| ContextualizedT2Reference |
Used by the
ReferenceService.traverseFrom(T2Reference, int) when
traversing a collection structure. |
| ErrorDocument |
Contains the definition of an error token within the workflow system.
|
| ErrorDocumentDao |
Data access object handling ErrorDocument instances.
|
| ErrorDocumentService |
Provides facilities to register list of T2References, register empty lists at
any given depth and to resolve appropriate T2Reference instances back to
these lists.
|
| ErrorDocumentServiceCallback |
Callback interface used by asynchronous methods in the
ErrorDocumentService interface |
| ExternalReferenceBuilderSPI<TargetType extends ExternalReferenceSPI> |
Constructs an ExternalReferenceSPI instance from a byte stream.
|
| ExternalReferenceSPI |
A reference to a single piece of data.
|
| ExternalReferenceTranslatorSPI<SourceType extends ExternalReferenceSPI,TargetType extends ExternalReferenceSPI> |
Constructs an ExternalReference instance from an existing ExternalReference,
most usually of a different type.
|
| Identified |
Interface for any object that has an associated
T2Reference |
| IdentifiedList<T> |
An identified list is a list which is identified by a T2Reference.
|
| ListDao |
Data access object handling NamedLists of T2Reference instances.
|
| ListService |
Provides facilities to register list of T2References, register empty lists at
any given depth and to resolve appropriate T2Reference instances back to
these lists.
|
| ListServiceCallback |
Callback interface used by asynchronous methods in the
ListService interface |
| ReferenceContext |
Many operations over the reference manager require access to an appropriate
context.
|
| ReferenceService |
Top level access point to the reference manager for client code which is
aware of references and error documents.
|
| ReferenceServiceCacheProvider |
A simple interface to be implemented by data access object cache providers,
intended to be used to inject cache implementations through AoP
|
| ReferenceServiceResolutionCallback |
Used by the asynchronous form of the resolveIdentifier method in
ReferenceService |
| ReferenceSet |
A set of ExternalReferenceSPI instances, all of which point to the same (byte
equivalent) data.
|
| ReferenceSetAugmentor |
Provides a framework to find and engage appropriate instances of
ExternalReferenceTranslatorSPI and
ExternalReferenceBuilderSPI to build external references from,
respectively, other external references and from streams. |
| ReferenceSetAugmentorCallback |
Callback interface used when augmenting a ReferenceSet in an asynchronous
fashion through
augmentReferenceSetAsynch in ReferenceSetAugmentor . |
| ReferenceSetDao |
Data Access Object interface for
ReferenceSet . |
| ReferenceSetService |
Provides facilities to register sets of ExternalReferenceSPI implementations
within the reference manager and to retrieve these sets by T2Reference either
as stored or with translation support.
|
| ReferenceSetServiceCallback |
Callback interface used by asynchronous methods in the
ReferenceSetService interface |
| StackTraceElementBean |
Used by the
ErrorDocument interface to represent a frame within a
stack trace |
| StreamToValueConverterSPI<T> |
SPI for objects that can render a POJO from an InputStream
|
| T2Reference |
The T2Reference is used within the workflow system to refer to any entity
within the reference management system, whether reference set, list or error
document.
|
| T2ReferenceGenerator |
Provides new unique T2Reference instances.
|
| ValueCarryingExternalReference<T> |
Specialization of ExternalReferenceSPI for reference types which carry a
value type internally.
|
| ValueToReferenceConverterSPI |
SPI for components that can convert an arbitrary object to an
ExternalReferenceSPI representing the value of that object.
|
| Class | Description |
|---|---|
| AbstractExternalReference |
A trivial implementation of ExternalReference.
|
| WorkflowRunIdEntity |
Entity that wraps workflow run id and can be passed through (
ReferenceContext to be used by T2ReferenceGenerator to
generate references that are specific for a workflow run. |
| Enum | Description |
|---|---|
| ReferencedDataNature |
Where possible ExternalReferenceSPI implementations should be able to
determine whether the data they refer to is textual or binary in nature.
|
| T2ReferenceType |
The T2Reference interface is used to identify several different kinds of
information, namely ReferenceSet, IdentifiedList and ErrorDocument.
|
| Exception | Description |
|---|---|
| DaoException |
Thrown by the Data Access Object interface methods, wrapping any underlying
exception.
|
| DereferenceException |
Thrown when a problem occurs during de-reference of an ExternalReferenceSPI
implementation.
|
| ErrorDocumentServiceException |
RuntimeException subclass thrown by the error document service layer
interfaces.
|
| ExternalReferenceConstructionException |
Thrown when an exception occurs during construction of an
ExternalReferenceSPI instance.
|
| ExternalReferenceValidationException |
Thrown by setter methods and constructors of ExternalReferenceSPI
implementations when fed parameters which cause some kind of format or
validation error.
|
| ListServiceException |
Thrown by methods in the ListService interface if anything goes wrong with
list registration or retrieval.
|
| ReferenceServiceException |
Thrown by methods in the ReferenceService, used to wrap any underlying
exceptions from lower layers.
|
| ReferenceSetAugmentationException |
Thrown when the reference set augmentor is unable to provide at least one of
the desired types for any reason.
|
| ReferenceSetServiceException |
RuntimeException subclass thrown by the reference set service layer
interfaces.
|
| ValueToReferenceConversionException |
Thrown by instances of ValueToReferenceConvertor when trying to convert an
object to an instance of ExternalReferenceSPI if the conversion process fails
for some reason.
|
Interfaces for the Taverna 2 reference manager. This replaces the (badly named) DataManager and is, in effect, a version 2 of that system. While these APIs are implementation neutral the intent is heavily towards the use of an object relational mapping (ORM) tool such as Hibernate backed by a relational database to hold the various collection, external reference and error documents managed by the reference manager.
For those familiar with the previous DataManager code the table below shows the old class names and the equivalent (where appropriate) in the new code:
| DataDocument | net.sf.taverna.t2.reference.ReferenceSet |
| ReferenceScheme | net.sf.taverna.t2.reference.ExternalReferenceSPI |
| EntityIdentifier | net.sf.taverna.t2.reference.T2Reference |
| ... |
One fundamental change is a move to runtime exceptions rather than checked exceptions. This follows the pattern used by Spring and Hibernate. The rationale is the same as in those systems - in general checked exceptions are not handled properly by client code. The loss of compiler level functionality from moving to runtime exceptions is countered by much higher readability of code which in itself leads to more robust and reliable systems.
A second change is the availability of asynchronous versions of all the critical APIs. Reference construction or translation in particular can be a costly process taking substantial time to complete. Synchronous versions of the get methods still exist but in general the simple callback based asynchronous ones are recommended over them for most applications.
Copyright © 2015–2016 The Apache Software Foundation. All rights reserved.


BOOKSFORME
HOME
SIGNUP
LOGIN
Sign Up
Congratulations You Sign Up successfully!!
Already have account?
Log In


Tacit is a CSS framework for dummies, who want their web services look attractive but have almost zero skills in graphic design, just like myself. This is how your website will look if you add just this code to your HTML:
<!DOCTYPE html> <html> <head> <link rel="stylesheet" type="text/css" href="//yegor256.github.io/tacit/tacit-VERSION.min.css"/> </head> </html>
You should not use any CSS classes to make your HTML code look nice. Just
make sure it is HTML5
compliant and you'll be fine. Again, no classes,
just standard HTML elements, like <table>
and <input>
.
Check the source code of this page.
Forms
Here is a simple form:
Tables
A simple table would look like this:
| Make | Price | Year |
|---|---|---|
| BMW X6 | $75,000 | 2013 |
| Mercedes-Benz E350 | $52,700 | 2014 |
Work in progress
The framework is still in development. If you want to contribute, fork it and submit a pull request. Your help is always apprecitated.


Magic Cube
Let's play !
Apesk
Don't let it get away.
Blocks Tower
Higher and higher !
STARFOX Arwing Drone
Through the star !
Mine Clearance
Look out,Boom !
Catch Cat
Don't let it get away.
Chicken Soup
Don't let it get away.
What To Eat
Don't let it get away.
Password -G
Don't let it get away.
Paint Board
Don't let it get away.


Accelerate with No Speed Traps
How do you use the web? Whether it's just you on your PC or your extended family simultaneously accessing the Internet for gaming, movie watching, surfing, or music; we have the speed for you — with no hidden fees, service charges, or other traps. Marlin Internet provides a broad variety of access plans at affordable prices with our exclusive ITIS 2.0 technology. We provide more than fast access. Take advantage of our 24/7 customer support (personal help is always on the line), free security tools, email accounts for the whole family, and exclusive online content.
| select a plan | Starter | Prime | Prime Plus | Ultra |
|---|---|---|---|---|
| $19.95 per month | $29.95 per month | $49.95 per month | $69.95 per month | |
| Summary | Just the speed you need to send emails, download map directions, and search the Internet for restaurant reviews. | A great speed at a great price for the family: kids can play games, adults can pay bills, and everyone can surf at the same time. | Super speeds for multiple tasks that require more broadband capacity; ideal for gamers who need fast response times. | Perfect for a small business running multiple media streams, demanding reduced lag time and fast data delivery. |
| Download Speed | 3 Mbps | 15 Mbps | 25 Mbps | 50 Mbps |
| Upload Speed | 512 Kbps | 6 Mbps | 10 Mbps | 20 Mbps |
| Cloud Strorage | 2 GB | 5 GB | 15 GB | 40 GB |
| E-mail Accounts | 2 Accounts | 3 Accounts | 5 Accounts | 10 Accounts |
| 24/7 Support | Yes | Yes | Yes | Yes |


This function is an addition to the swmmr package. The function inp_to_files is used to convert SWMM projects saved as .inp to several independent files. While geographical informations are stored in .shp files, informations of the sections options, report, raingages, evaporation, pollutants, landuses, buildup, washoff and coverages are stored in one .txt file named ‘options.txt’. Furthermore timeseries are converted to SWMM’s timeseries format and saved in .dat files.
The usage of swmmr’s function inp_to_files is explained with Example1 shipped with the SWMM executable:
# in case your operating system is Windows, the examples are saved in the following directory:
# "C:/Users/.../Documents/EPA SWMM Projects/Examples/"
# please change the path to:
# "C:/Users/.../Documents/EPA_SWMM_Projects/Examples/"
# substitute '...' with your user name
# set path to inp
# If your operating system is Windows, the Example1.inp model is usually
# located at "C:\Users\your user name\Documents\EPA SWMM Projects\Examples".
# For convenience the Example1.inp model is also included in the swmmr package.
# Feel free to change this to your path of choice.
inp_file <- system.file("extdata", "Example1.inp", package = "swmmr", mustWork = TRUE)
# set the path to the output directory for the example files (here, we use a temp directory)
# Feel free to change this to your path of choice.
out_dir <- tempdir()
# read the "Example1.inp" using read_inp
Example1 <- read_inp(x = inp_file)
# glance the structure of Example1
summary(Example1)
##
## ** summary of swmm model structure **
## infiltration : horton
## flow_units : cfs
## flow_routing : kinwave
## start_date : 01/01/1998
## end_date : 01/02/1998
## raingages : 1
## subcatchments : 8
## aquifers : 0
## snowpacks : 0
## junctions : 13
## outfalls : 1
## dividers : 0
## storages : 0
## conduits : 13
## pumps : 0
## orifices : 0
## weirs : 0
## outlets : 0
## controls : 0
## pollutants : 2
## landuses : 2
## lid_controls : 0
## treatment : 0
## *************************************
# convert .inp file into independent .shp and .txt files
inp_to_files(x = Example1, name = "Example1", path_out = out_dir)
## Warning in abbreviate_shapefile_names(obj): Field names abbreviated for
## ESRI Shapefile driver
## Writing layer `Example1_polygon' to data source `/var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/shp/Example1_polygon.shp' using driver `ESRI Shapefile'
## features: 8
## fields: 22
## geometry type: Polygon
## Writing layer `Example1_link' to data source `/var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/shp/Example1_link.shp' using driver `ESRI Shapefile'
## features: 13
## fields: 16
## geometry type: Line String
## Writing layer `Example1_point' to data source `/var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/shp/Example1_point.shp' using driver `ESRI Shapefile'
## features: 13
## fields: 6
## geometry type: Point
## Writing layer `Example1_outfall' to data source `/var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/shp/Example1_outfall.shp' using driver `ESRI Shapefile'
## features: 1
## fields: 6
## geometry type: Point
## section weirs is missing
## section orifices is missing
## section pumps is missing
## section storage is missing
## *.shp files were written to /var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/shp
## *.txt file was written to /var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/txt
## section curves is missing
## timeseries.dat files were written to /var/folders/5s/kgm05t2s0_52gz1s445mnlgw0000gn/T//Rtmp7YYaAn/dat
## [1] "dat" "file736a15c39de6" "file736a5db37233"
## [4] "shp" "txt"
# check existence of shape, text and dat files:
c("shp", "txt", "dat") %>%
map( ~ file.path(out_dir, .)) %>%
map(list.files)
## [[1]]
## [1] "Example1_link.dbf" "Example1_link.shp" "Example1_link.shx"
## [4] "Example1_outfall.dbf" "Example1_outfall.shp" "Example1_outfall.shx"
## [7] "Example1_point.dbf" "Example1_point.shp" "Example1_point.shx"
## [10] "Example1_polygon.dbf" "Example1_polygon.shp" "Example1_polygon.shx"
##
## [[2]]
## [1] "Example1_options.txt"
##
## [[3]]
## [1] "Example1_timeseries_TS1.dat"
This is the counterpart to inp_to_files. Geographical informations stored in .shp files are converted to the input file format ‘.inp’ of SWMM using R. Informations on simulation settings, rain timeseries etc., stored in .txt or .dat files, complete these geographical informations.
Based on the converted files of Example1, the usage of swmmr’s function shp_to_inp is explained:
# convert shp and txt files to inp object:
Example1_con <- shp_to_inp(
path_options = file.path(out_dir,"txt/Example1_options.txt"),
path_timeseries = file.path(out_dir,"dat/Example1_timeseries_TS1.dat"),
path_polygon = file.path(out_dir,"shp/Example1_polygon.shp"),
path_line = file.path(out_dir,"shp/Example1_link.shp"),
path_point = file.path(out_dir,"shp/Example1_point.shp"),
path_outfall = file.path(out_dir,"shp/Example1_outfall.shp")
)
# glance the structure of the converted Example1
summary(Example1_con)
##
## ** summary of swmm model structure **
## infiltration : horton
## flow_units : cfs
## flow_routing : kinwave
## start_date : 01/01/1998
## end_date : 01/02/1998
## raingages : 1
## subcatchments : 8
## aquifers : 0
## snowpacks : 0
## junctions : 0
## outfalls : 1
## dividers : 0
## storages : 0
## conduits : 13
## pumps : 0
## orifices : 0
## weirs : 0
## outlets : 0
## controls : 0
## pollutants : 2
## landuses : 2
## lid_controls : 0
## treatment : 0
## *************************************
# save the input file to a new folder in the output directory:
dir.create(file.path(out_dir, "inp_new"))
write_inp(Example1_con, file.path(out_dir, "inp_new", "Example1_con.inp"))
Now simulation runs can be initiated…
There are three different ways to define the parameters of the different SWMM sections:
Here examples for the structure of supplementary R objects are given:
# ... assuming infiltration parameters are not given in the .shp file, an R object (tibble or data.frame) called infiltration can be added. Additionally a column 'Soil' must be added to polygon shp file.
infiltration <- tibble(
Soil = c("A", "B"), # or: unique(polygon$Soil)
MaxRate = c(76.2, 127),
MinRate = c(3.81, 7.62),
Decay = c(0.069, 0.069),
DryTime = c(1,1),
MaxInf = c(0,0)
)
# ... assuming not all subcatchment related parameters are given in the polygon .shp-file, an R object (tibble or data.frame) called subcatchment_typologies can be added. Additionally a column 'Type' must be added to the polygon .shp file.
subcatchment_typologies <- tibble(
Type = c("Street", "Park"), # or: unique(polygon$Type)
Perc_Imperv = c(100, 10),
Width = c(9, 30),
Slope = c(0.57, 1),
CurbLen = 0,
Snowpack = ' ',
Rain_Gage = "Test_rain",
N_Imperv = c(0.01, 0.025),
N_Perv = c(0.01, 0.2),
S_Imperv = c(1.5, 0.58),
S_Perv = c(1.5, 0.58),
Pct_Zero = 0,
PctRouted = 100
)
#...assuming roughness is not given in the line .shp file, an R object (tibble or data.frame) called conduit_material can be added. Additionally a column 'Material' must be added to the line .shp file
conduit_material <- tibble(
Material = "B", # or: unique(lines$Material)
Roughness = 0.018
)
#... assuming surcharge of junctions should be added later:
junction_parameters <- tibble(
Y = 0,
Ysur = 1,
Apond = 1
)
The shp_to_inp function relies on the correct naming of the column names given in the .shp files: either you use the original swmm encoding (also given in swmmr::read_inp) or the swmm encoding abbreviated to seven characters (which is coerced when storing shp files, e.g. with sf::st_write).
In the moment, inp_to_files and shp_to_inp support the following SWMM inp sections:
The following sections are implemented with restrictions:


Dynamic Full-Stack Developer with hands-on experience creating front end applications in Python, C# / .NET, and MERN(React) as well as backend applications to build databases and deploy full applications.
Pet Shelter demo website developed using MERN(MongoDB, Express.js, React, and Node.js) and deployed onto Amazon AWS(EC2). This demo allows multiple users to add pets for adoption, adopt pets, like pets, and edit pet information. Demo features login/registration/updating validations, Bycrypt password hashing, and CRUD (Create, Read, Update, Destroy) routes using NoSQL database MongoDB with RESTful-API.
Travel organizer developed using Python, Django, SQLite, HTML, and CSS. Allows multiple registered users to coordinate travel plans and join travel itineraries via SQLite connections and a user friendly web interface. Featuring login validations, Bcrypt password hashing, Session, and various schema relationships. Deployed using Amazon AWS (EC2).


troff '\" t .\" Title: mkvextract .TH "MKVEXTRACT" "1" "2015\-02\-28" "MKVToolNix 7\&.7\&.0" "User Commands" .\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" ----------------------------------------------------------------- .nh .\" disable justification (adjust text to left margin only) .ad l .\" ----------------------------------------------------------------- .SH "NAME" mkvextract \- extract tracks from Matroska(TM) files into other files .SH "SYNOPSIS" .HP \w'\fBmkvextract\fR\ 'u \fBmkvextract\fR {mode} {source\-filename} [options] [extraction\-spec] .SH "DESCRIPTION" .PP .B mkvextract extracts specific parts from a .I Matroska(TM) file to other useful formats\&. The first argument, \fBmode\fR, tells \fBmkvextract\fR(1) what to extract\&. Currently supported is the extraction of tracks, tags, attachments, chapters, CUE sheets, timecodes and cues\&. The second argument is the name of the source file\&. It must be a Matroska(TM) file\&. All following arguments are options and extraction specifications; both of which depend on the selected mode\&. .SS "Common options" .PP The following options are available in all modes and only described once in this section\&. .PP \fB\-f\fR, \fB\-\-parse\-fully\fR .RS 4 Sets the parse mode to \*(Aqfull\*(Aq\&. The default mode does not parse the whole file but uses the meta seek elements for locating the required elements of a source file\&. In 99% of all cases this is enough\&. But for files that do not contain meta seek elements or which are damaged the user might have to use this mode\&. A full scan of a file can take a couple of minutes while a fast scan only takes seconds\&. .RE .PP \fB\-\-command\-line\-charset\fR \fIcharacter\-set\fR .RS 4 Sets the character set to convert strings given on the command line from\&. It defaults to the character set given by system\*(Aqs current locale\&. .RE .PP \fB\-\-output\-charset\fR \fIcharacter\-set\fR .RS 4 Sets the character set to which strings are converted that are to be output\&. It defaults to the character set given by system\*(Aqs current locale\&. .RE .PP \fB\-r\fR, \fB\-\-redirect\-output\fR \fIfile\-name\fR .RS 4 Writes all messages to the file \fIfile\-name\fR instead of to the console\&. While this can be done easily with output redirection there are cases in which this option is needed: when the terminal reinterprets the output before writing it to a file\&. The character set set with \fB\-\-output\-charset\fR is honored\&. .RE .PP \fB\-\-ui\-language\fR \fIcode\fR .RS 4 Forces the translations for the language \fIcode\fR to be used (e\&.g\&. \*(Aqde_DE\*(Aq for the German translations)\&. It is preferable to use the environment variables \fILANG\fR, \fILC_MESSAGES\fR and \fILC_ALL\fR though\&. Entering \*(Aqlist\*(Aq as the \fIcode\fR will cause \fBmkvextract\fR(1) to output a list of available translations\&. .\" [...] .SH "SEE ALSO" .PP \fBmkvmerge\fR(1), \fBmkvinfo\fR(1), \fBmkvpropedit\fR(1), \fBmmg\fR(1) .SH "WWW" .PP The latest version can always be found at \m[blue]\fBthe MKVToolNix homepage\fR\m[]\&\s-2\u[1]\d\s+2\&. .SH "AUTHOR" .PP \(co \fBMoritz Bunkus\fR<EMAIL_ADDRESS>.RS 4 Developer .RE .SH "NOTES" .IP " 1." 4 the MKVToolNix homepage .RS 4 \%https://www.bunkus.org/videotools/mkvtoolnix/ .RE MIME types defined: troff.


The Pagination filter extracts segments matching /page/:page from the end of the recognized url and exposes the page parameter as params[:page]. When a url is generated the filter adds the segments to the url accordingly if the page parameter is passed to the url helper.
incoming url: /products/page/1 filtered url: /products params: params[:page] = 1
You can install the filter like this:
# in config/routes.rb Rails.application.routes.draw do filter :pagination end
To make your named_route helpers or url_for add the pagination segments you can use:
products_path(:page => 1) url_for(:products, :page => 1)
Classes and Modules
- MODULE RoutingFilter


IO¶
Loading a model¶
A model can be loaded from a .json, a .mat file or from a table (csv/tsv) using the methods:
load_json(file, fix = true)
load_matlab(filename; fix = true, model_key = "", x...)
load_table(filename, [delimiter = ',', fix = true])
Note The parameter fix
is always set to true by default, this runs the method fix_model()
which calls the following methods
fix_empty_fields()
which fills up fields that were not in the loaded filefix_extra_dicts()
fills up extra dictionaries so their length matchesfix_gene_rules()
which tries to find all flaws in gene reaction rulesfix_genes()
removes genes that dont appear in any gene reaction rule
Note that fix_gene_rules()
and fix_genes()
may both need to be run, so not running one may introduce errors.
So if you wish not one of these methods to run, it is reccomended to run the others manually to avoid errors. Please see the documentation if futher information is required.
Loading JSON¶
julia> model = load_json("Models/e_coli_core.json")
rxns : 95 Array{String,1}
mets : 72 Array{String,1}
genes : 137 Array{String,1}
S : 6840 SparseMatrixCSC{Float64,Int64}
lb : 95 Array{Float64,1}
ub : 95 Array{Float64,1}
c : 95 Array{Float64,1}
b : 72 Array{Float64,1}
csense : 3 Dict{String,Array{Any,1}}
rxn_gene_mat : 13015 SparseMatrixCSC{Float64,Int64}
rxn_name : 95 Array{String,1}
rxn_rules : 95 Array{String,1}
rxn_subsystem : 95 Array{String,1}
rxn_extra : 3 Dict{String,Array{Any,1}}
met_formula : 72 Array{String,1}
met_name : 72 Array{String,1}
met_extra : 2 Dict{String,Array{Any,1}}
gene_name : 137 Array{String,1}
gene_extra : 1 Dict{String,Array{Any,1}}
description : 11 String
Loading Matlab¶
julia> model = load_matlab("Models/ecoli_core_model.mat")
rxns : 95 Array{String,1}
mets : 72 Array{String,1}
genes : 137 Array{String,1}
S : 6840 SparseMatrixCSC{Float64,Int64}
lb : 95 Array{Float64,1}
ub : 95 Array{Float64,1}
c : 95 Array{Float64,1}
b : 72 Array{Float64,1}
csense : 3 Dict{String,Array{Any,1}}
rxn_gene_mat : 13015 SparseMatrixCSC{Float64,Int64}
rxn_name : 95 Array{String,1}
rxn_rules : 95 Array{String,1}
rxn_subsystem : 95 Array{String,1}
rxn_extra : 3 Dict{String,Array{Any,1}}
met_formula : 72 Array{String,1}
met_name : 72 Array{String,1}
met_extra : 2 Dict{String,Array{Any,1}}
gene_name : 137 Array{String,1}
gene_extra : 1 Dict{String,Array{Any,1}}
description : 11 String
Load Table (csv/tsv)¶
To load a model from a table, fx from a .csv file
julia> model = load_table("./ecoli/e_coli", ',')
rxns : 95 Array{Any,1}
mets : 72 Array{Any,1}
genes : 137 Array{Any,1}
S : 13680 SparseMatrixCSC{Float64,Int64}
lb : 95 Array{Any,1}
ub : 95 Array{Any,1}
c : 95 Array{Any,1}
b : 72 Array{Any,1}
csense : 3 Dict{Any,Any}
rxn_gene_mat : 0 Array{Any,1}
rxn_name : 95 Array{Any,1}
rxn_rules : 95 Array{Any,1}
rxn_subsystem : 95 Array{Any,1}
rxn_extra : 0 Array{Any,1}
met_formula : 72 Array{Any,1}
met_name : 72 Array{Any,1}
met_extra : 0 Array{Any,1}
gene_name : 137 Array{Any,1}
gene_extra : 0 Array{Any,1}
description : 0 Array{Any,1}
Note that these table files need to be specifically structured:
Inside the “/ecoli/” directory there must be 4 files.
- e_coli_rxns.csv
- e_coli_mets.csv
- e_coli_genes.csv
- e_coli_constraints.csv
Note No additional fields are included in the model when loading from a tabular file
e_coli_rxns.csv¶
With 8 columns, with the column contents as:
reaction id
reaction lower bounds
reaction upper bounds
objective coefficient, c, usually 0 for all, except 1 for the biomass function
reaction name
reaction gene rules
reaction subsystem
reaction formula
Note: that if the
<=
,=
and=>
are not wrapped with spacing, they wont be detected, so make sure they have spaces around them.
A line from ecoli_rxns.csv may look like:
ETOHt2r,-1e3,1e3,0,ETOHt2r,,"Transport, Extracellular",etoh_e + h_e <=> etoh_c + h_c
e_coli_mets.csv¶
With 3 columns, with the column contents as:
- metabolite id (as it appears in reaction formulas)
- metabolite formula
- metabolite name
A line from ecoli_mets.csv may look like:
coa_c,C21H32N7O16P3S,Coenzyme A
e_coli_genes.csv¶
With 2 columns, with the column contents as:
- gene id (as it appears in the reaction gene rule)
- gene name
A line from ecoli_genes.csv may look like:
b0727,sucB
e_coli_constraints.csv¶
With 2 columns, with the column contents as:
- b, usually an array of the same length as the metabolites, but filled with zeros
- constraint sense, usually an array of the same length as the metabolites, but filled with
=
A line from ecoli_constraints.csv may look like:
0,=
Troubleshooting¶
There may be some inconsistent models, so they wont be able to load properly.
.json¶
JSON-files are parsed as nested dictionaries in Julia. For a model in .json format to load properly, its structure must be consistent with the JSON-structure of models found in the BiGG model database
The following is the required structure for .json models:
model: {}
reactions: []
upper_bound : number *
lower_bound : number *
subsystem : string
name : string
gene_reaction_rule : string *
id : string *
metabolites: {} *
metabolite : coefficient
genes: []
name : string
id : string *
metabolites: []
formula : string
compartment : string
name : string
id : string *
Everything else goes into the fields rxn_extra, met_extra and gene_extra.
This structure must be followed for the model to load properly and the ones marked with * must be present for all functionality to be available
.mat¶
Matlab files are saved as a dictionary of variables, different from .json in the sense that .mat files arent nested, i.e not dictionaries within dictionaries.
The following must be either present or provided in a .mat file:
rxns
mets
genes
S
lb
ub
c
b
csense
rxnGeneMat
rxnNames
grRules
subSystems
metFormulas
metNames
description
However, if fx in your model.mat file, “rxns” is saved as “rxn_ids” you can call:
load_matlab(model, rxns = "rxn_ids")
To let the function know that “rxns” is called “rxn_ids” in your .mat file
There can be multiple corrections
load_matlab(model, rxns = “rxn_ids”, grRules = “rules”)
csense¶
csense will be converted into a dictionary:
julia> model.csense
Dict{String,Array{Any,1}} with 3 entries:
"<=" => Any[]
"=" => Any[1,2,3 … 71,72]
">=" => Any[]
csense is not strictly necessary, if csense is not present in a model, csense will be generated automatically
Exporting a model¶
A model can be exported in JSON/Matlab and Table format:
export_json(model, filename);
export_matlab(model, filename);
This will create a .json/.mat file, “ecoli.json”
To export model to a table, do:
export_table(model, filename; [delimiter = ',', overwrite = false])
For example:
export_table(model, "./ecoli/ecoli"; ',', false)
It is reccomended to store every tabular model in a private folder, as this method creates 4 files:
./ecoli/ecoli_rxns.csv
./ecoli/ecoli_mets.csv
./ecoli/ecoli_genes.csv
./ecoli/ecoli_constraints.csv
Separated by commas, ,
.
Note: By default, overwrite
is set to false
, meaning that you cannot accidentally overwrite existing tabular files, the method will return an error.
However, if overwriting is desired, do:
export_table(model, "./ecoli/ecoli"; ',', true)
IO Tools¶
CBM has a few tools indented for IO operation for the users convenience.
load_model()
¶
load_model
is simply a wrapper for load_json()
and load_matlab()
.:
model = load_model(filename [,fix = true])
Example¶
Load e_coli_core
(which we know is in .json
):
julia> load_model("/home/david/Julia/Models/e_coli_core")
rxns : 95 Array{String,1}
mets : 72 Array{String,1}
genes : 137 Array{String,1}
S : 6840 SparseMatrixCSC{Float64,Int64}
lb : 95 Array{Float64,1}
ub : 95 Array{Float64,1}
c : 95 Array{Float64,1}
b : 72 Array{Float64,1}
csense : 3 Dict{String,Array{Any,1}}
rxn_gene_mat : 13015 SparseMatrixCSC{Float64,Int64}
rxn_name : 95 Array{String,1}
rxn_rules : 95 Array{String,1}
rxn_subsystem : 95 Array{String,1}
rxn_extra : 3 Dict{String,Array{Any,1}}
met_formula : 72 Array{String,1}
met_name : 72 Array{String,1}
met_extra : 2 Dict{String,Array{Any,1}}
gene_name : 137 Array{String,1}
gene_extra : 1 Dict{String,Array{Any,1}}
description : 11 String
open_mat_file
¶
Return a dictionary with the variables from a .mat
file:
dict = open_mat_file(filename)
Example¶
Lets open up the .mat
file variables.mat
which we know contains the variables var_a
and var_b
julia> open_mat_file(“/home/david/variables.mat”) Dict{String,Any} with 2 entries:
“var_a” => “[1,2,3,4]” “var_b” => “hello”
save_mat_file
¶
Saves variables to a .mat
file:
save_mat_file(filename; [args...])
Using this is not entirely intuitive so I will provide an example
Example¶
Lets create the variables a
and b
:
julia> a = [1,2,3,4]
4-element Array{Int64,1}:
1
2
3
4
julia> b = "hello"
"hello"
And then we save them to the file /home/david/variables.mat
as var_a
and var_b
:
julia> save_mat_file("/home/david/variables.mat", var_a = a, var_b = b)


Welcome to Yet Another Time Table Application.
This app shows real time information on Västtrafik departures for a given stop (similar to the "Nästa tur" digital displays).
Click the menu bar in the upper-left corner to configure what stop, lines and tracks to monitor.
Visit the Github repo for more information.


Support every underserved studentTutorbook's ease of use ensures every student can find
and be supported by the peer tutor they need.assets/phones.pngCheck it outCoordinate tutoring across schoolsConnect middle and elementary school students with high
school mentors.assets/laptop.pngCheck it outCentralize your program's workflowToo many tools? Too much chaos? Manage all facets of
peer tutoring in a single place.assets/desktop.pngCheck it out


BIO
I am currently a graduate research assistant in the Web and Complex Systems Lab and Kno.e.sis Research Center in the computer science department at Wright State University, working towards a Master's of Science in Computer Science under the advisement of Dr. Derek Doran.
I am fascinated with the notation of mapping mathematical and statistical ideas to real data with impact. Currently I am interested in combining ideas from machine learning, network science, and time series to tackle problems in complex systems. I will be pursuing a PhD with a focus in network science and machine learning starting Fall 2018.
I am actively looking for summer internship in data science or data analyst related positions for 2018! Feel encouraged to contact me at<EMAIL_ADDRESS>with opportunities.
I am actively looking for summer internship in data science or data analyst related positions for 2018! Feel encouraged to contact me at<EMAIL_ADDRESS>with opportunities.


com.nexmo.messaging.sdk.messages
Class Message
java.lang.Object
com.nexmo.messaging.sdk.messages.Message
- All Implemented Interfaces:
- java.io.Serializable
- Direct Known Subclasses:
- BinaryMessage, TextMessage, UnicodeMessage, USSDDisplayMessage, USSDPromptMessage, WapPushMessage
public abstract class Message
- extends java.lang.Object
- implements java.io.Serializable
Message.java
Created on 5 January 2011, 17:34
Represents the details of a message that is to be submitted via the http api.
Not instanciated directly, but instead via one of the sub-classes that represent a particular message type
- Version:
- 1.0
- Author:
- Paul Cook
- See Also:
- Serialized Form
|
Field Summary |
static int |
MESSAGE_TYPE_BINARY
Message ia a binary SMS message with a custom UDH and binary payload |
static int |
MESSAGE_TYPE_TEXT
Message ia a regular TEXT SMS message |
static int |
MESSAGE_TYPE_UNICODE
Message is a unicode message, for sending messages in non-latin script to a supported handset |
static int |
MESSAGE_TYPE_USSD_DISPLAY
Message is a USSD 'display' message that displays on handset but does not require a response |
static int |
MESSAGE_TYPE_USSD_PROMPT
Message is a USSD 'prompt' message that requires a response from the end user |
static int |
MESSAGE_TYPE_WAPPUSH
Message is a wap-push message to send a browsable / downloadable url to the handset |
| Methods inherited from class java.lang.Object |
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
MESSAGE_TYPE_TEXT
public static final int MESSAGE_TYPE_TEXT
- Message ia a regular TEXT SMS message
- See Also:
- Constant Field Values
MESSAGE_TYPE_BINARY
public static final int MESSAGE_TYPE_BINARY
- Message ia a binary SMS message with a custom UDH and binary payload
- See Also:
- Constant Field Values
MESSAGE_TYPE_WAPPUSH
public static final int MESSAGE_TYPE_WAPPUSH
- Message is a wap-push message to send a browsable / downloadable url to the handset
- See Also:
- Constant Field Values
MESSAGE_TYPE_UNICODE
public static final int MESSAGE_TYPE_UNICODE
- Message is a unicode message, for sending messages in non-latin script to a supported handset
- See Also:
- Constant Field Values
MESSAGE_TYPE_USSD_DISPLAY
public static final int MESSAGE_TYPE_USSD_DISPLAY
- Message is a USSD 'display' message that displays on handset but does not require a response
- See Also:
- Constant Field Values
MESSAGE_TYPE_USSD_PROMPT
public static final int MESSAGE_TYPE_USSD_PROMPT
- Message is a USSD 'prompt' message that requires a response from the end user
- See Also:
- Constant Field Values
getType
public int getType()
- Returns:
- int the type of message will influence the makeup of the request we post to the Nexmo server, and also the action taken by the Nexmo server in response to this message
getFrom
public java.lang.String getFrom()
- Returns:
- String the 'from' address that will be seen on the handset when this message arrives,
typically either a valid short-code / long code that can be replied to, or a short text description of the application sending the message (Max 11 chars)
getTo
public java.lang.String getTo()
- Returns:
- String the phone number of the handset that you wish to send the message to
getMessageBody
public java.lang.String getMessageBody()
- Returns:
- String The text of the message to be sent to the handset
getBinaryMessageBody
public byte[] getBinaryMessageBody()
- Returns:
- byte[] The raw binary message data to be sent to a handset.
This api, and the Nexmo messaging service will send this data 'as-is' (in conjunction with the binary UDH) and will not make any corrections.
so you should ensure that it is a correctly constructed message
getBinaryMessageUdh
public byte[] getBinaryMessageUdh()
- Returns:
- byte[] Most binary content will require a UserDataHeader portion of the message containing commands to enable the handset to interpret the binary data
(for example, a binary ringtone, a wap-push, OverTheAir configuration, etc).
Additionally, if you are sending a long text message as multiple concatenated messages and are performing this operation manually rather than
using the automated long messaging handling in the Nexmo messaging service, then you will need to construct and include here an appropriate
UserDataHeader field that describes the segmentation/re-assembly fields required to sucessfully concatenate multiple short messages.
getClientReference
public java.lang.String getClientReference()
- Returns:
- String This is a user definable reference that will be stored in the Nexmo messaging records. It will be available in detailed reporting / analytics
In order to help with reconcilliation of messages
isUnicode
public boolean isUnicode()
- Returns:
- boolean This flag is set to true if the message needs to be submitted as a unicode message. This would be for scenario's where the message contains text that does not
fit within the Latin GSM alphabet. Examples would be messages to be sent in non-western scripts, such as Arabic, Kanji, Chinese, etc.
getStatusReportRequired
public boolean getStatusReportRequired()
- Returns:
- boolean If set to true, then a delivery notification will be requested for this message delivery attempt.
Upon receiving notification of delivery or failure from the network, the Nexmo platform will submit a notification to the url configured in your
Nexmo REST account that represents the outcome of this message.
getWapPushUrl
public java.lang.String getWapPushUrl()
- Returns:
- String This is the url that will be submitted to the handset and will appear as a browsable message in the Inbox.
getWapPushTitle
public java.lang.String getWapPushTitle()
- Returns:
- String This is the title that will be associated with the url being submitted to the handset
getWapPushValidity
public int getWapPushValidity()
- Returns:
- int This is the length of time (in seconds) that the message will be available for once delivered to the handset.
Once this time has expired, the url will no longer be visible on the handset to be browsed (Subject to handset compatibility)
getMessageClass
public MessageClass getMessageClass()
- Returns:
- com.nexmo.messaging.sdk.messages.parameters.MessageClass The message class that is to be applied to this message.
getProtocolId
public java.lang.Integer getProtocolId()
- Returns:
- Integer The value of the GSM Protocol ID field to be submitted with this message. Ordinarily this should be left as the default value of 0


Feature Films
Short Films
teatrical shorts
disney+
sparkshorts
cars toons
toy story toons
home entertaiment
Technology
renderman
graphic technologies
Careers
careers at pixar
interships
life at pixar
events
Extras
pixar in concert
art exhibition
pixar in a box
the science behind pixar
About
contact us
leadership
inclusion & outreach
coming soon
our story
company faq's
Careers at pixar
Soul Trailers
Inclusion and outreach


Edit Transaction
Product Category
Serial No
Transaction Date
Customer Name
Email
Modify customer
Edit the current customer
Change to existing customer
Replace with a new customer
Make
<-- Select -->
Model
<-- Select -->
Status
<-- Select -->
Accessories
Complaint Reported
Complaint Diagnosed
Engineer Remarks
Repair Action
Notes
Update
Cancel
Edit Customer
Lets edit customer....
Find Customer
Add Customer
Lets add a customer....


School of Architecture.
School of Architecture.
1.Expert lecture on Frank Owen Gehry and Louis Vuitton Foundation
School of Architecture, REVA University organized an expert lecture on Frank Owen Gehry and one of his famous work- Louis Vuitton Foundation, Paris on March 7, 2019 at the Kalpana Chawla Seminar hall from 9:30 to 10:30AM. This talk was organized mainly for the 4thsemester students, as part of their curriculum, where they are introduced to the master Architects of Post Modernism and Deconstructivism.
2.Slogan writing competition
The Jalandolana and LITWITS-literary club of School of Architecture, REVA University organised a slogan writing competition on March 7, 2019 at the Amphitheatre, CV Raman Block from 10:30-11:30 AM. The slogan writing competition was organised as one of the pre events for Jalandolana where students were invited to write slogans to highlight the importance of water and need to save our lakes.
3.Expert Lecture on “Infill design in historic precincts”
School of Architecture, REVA University organized an expert lecture on “Infill design in historic precincts”, by Prof. Raghu Teja V., Associate Professor, School of Architecture on 11th March, 2019 at AV Room 123. This talk was organized mainly for the 4th semester students, as a part of their curriculum, where they are designing a tourist lodge within the historic precincts of Barkur town in Udupi district of Karnataka.
Report on Data for INSIGHT APP From Feb 28, 2019 to march 6, 2019
1.Field trip to study Pre-Engineered Buildings
School of Architecture, REVA University organized a guest lecture on ‘Byzantine Architecture’ by Ar.Iliona Outram Khalili, on 21st February, 2019 at AV Room 103, Vivekananda Block. This talk was organized mainly for the 2nd semester students, as part of their curriculum, where they have to be introduced to the Early Christian and Byzantine Architecture. Byzantine_1
2.Expert Lecture on Hagia Sophia, Istanbul, Turkey- An architectural marvel of Byzantine Empire’
School of Architecture, REVA University organized a guest lecture on ‘Hagia Sophia, Istanbul, Turkey- An architectural marvel of Byzantine Empire’ by Ar. Vidya Srikanth, on 21st February, 2019 at AV Room 103, Vivekananda Block. This talk was organized mainly for the 2nd semester students, as part of their curriculum, where they have to be introduced to the Early Christian and Byzantine Architecture.
3.Visit to St. John’s Church, St. Francis Xavier Cathedral And Fort High School for 2nd semester, B.Arch students
The students of 2nd semester, B.Arch were taken on a site visit within Bangalore on 23rd February 2019. They visited St. John’s church and St. Francis Xavier cathedral in Frazer town followed by a visit to fort high school at Chamrajpet. The visit was aimed at enhancing their understanding of Christian architecture as a part of their course curriculum.
Report on Data for INSIGHT APP From Feb 15 ,2019 to Feb 20 ,2019
1.Expert Lecture on Byzantine Architecture
School of Architecture, REVA University organized a guest lecture on ‘Byzantine Architecture’ by Ar.Iliona Outram Khalili, on 21st February, 2019 at AV Room 103, Vivekananda Block. This talk was organized mainly for the 2nd semester students, as part of their curriculum, where they have to be introduced to the Early Christian and Byzantine Architecture.
2.Expert Lecture on Hagia Sophia, Istanbul, Turkey- An architectural marvel of Byzantine Empire’
School of Architecture, REVA University organized a guest lecture on ‘Hagia Sophia, Istanbul, Turkey- An architectural marvel of Byzantine Empire’ by Ar. Vidya Srikanth, on 21st February, 2019 at AV Room 103, Vivekananda Block. This talk was organized mainly for the 2nd semester students, as part of their curriculum, where they have to be introduced to the Early Christian and Byzantine Architecture.
3.Visit to St. John’s Church, St. Francis Xavier Cathedral And Fort High School for 2nd semester, B.Arch students
The students of 2nd semester, B.Arch were taken on a site visit within Bangalore on 23rd February 2019. They visited St. John’s church and St. Francis Xavier cathedral in Frazer town followed by a visit to fort high school at Chamrajpet. The visit was aimed at enhancing their understanding of Christian architecture as a part of their course curriculum.
HOA_1 to HOA_7
Report on Data for INSIGHT APP From Feb 15 ,2019 to Feb 20 ,2019
1.Expert Lecture on Building Services, Mechanical ventilation (HVAC)
School of Architecture, REVA University organized an expert lecture on Building Services, Mechanical ventilation (HVAC) at room number 103, 1st floor, Swami Vivekananda block on 15 Feb 2019 from 1.30 to 3.45 pmby Prof. Lakshminarasimha. N., IGBC AP, M.Tech (Thermal Engg. - Gold Medalist), Mechanical Engineering Department, New Horizon College of Engineering, Bangalore.
2.Visit to under-construction site at Bagalur cross
A visit to under construction project site was organized as a part of curriculum for 6th semester students of Architecture on 18 Feb 2019. The study gave an insight to the students regarding transmitting drawings prepared in architectural studios to actual project sites. Faculty members Ar Shama Parween, Ar Ujjal Halder, Ar Nazish Abid accompanied the students for the site visit.
3.Expert Lecture on ‘Earth as a building material- an objective and subjective analysis’
School of Architecture, REVA University organized an expert lecture on ‘Earth as a building material- an objective and subjective analysis’, by Professor Rajesh Malik, School of Architecture on 14th February, 2019 at AV Room 124. This talk was organized mainly for the 4th semester students, as part of their curriculum, where they have to be introduced to the structural integrity of different building materials.
About the Event
FACULTY ACHIEVEMENT
Report on Data for INSIGHT APP From Feb 15 ,2019 to Feb 20 ,2019
1.School of Architecture Faculty members attend Council of Architecture Teachers Training Program at Pune
Ar. Vidya Srikanth and Ar. Shubhi S from School of Architecture were nominated to attend Council of Architecture Teachers Training program on Advanced Architectural theories from 28th Jan-1st Feb 2019 at COA-TRC, Pune. The intensive training session involved lecture sessions by renowned architects such as Ar. Pradnya Chouhan, Ar. Durganand Balsavar, Ar. Chethan Sahasrabudhe, Ar. Kaber Fatema and Ar. Jayshree Deshpande. The program concluded with group wise preparation of Book manuals which can be used as easy to comprehend visual tools in the design studios across semesters. The book manuals prepared by the participants during the 5 day program are now under review for publication by COA-TRC and will be shared to Architecture schools across India after publication.
2.School of Architecture Faculty member selected for International workshop in Bali and China
Ar. Yashaswini N., Asst. professor at School of Architecture was selected to participate in a 12 days architecture workshop titled-“The Spatial intensive”. The program explored engineering and artistic environment in Asia through guided visits to Bali and China. The program included visits to award winning projects, landmarks, workshops, curated walks and also a conscious effort to understand and explore the mixture of art and craft with modern architecture.
3.School of Architecture faculty member presents paper at International conference at Ireland
Ar. Anup Kumar Prasad successfully presented my research paper Topic Significance of Indo-Saracenic Architecture in India during British Raj at All Ireland Architectural Research Group 8, hosted by Dublin School of Architecture, Dublin, Ireland, on 24th and 25th January 2019.
STUDENT/FACULTY ACHIEVEMENT
4.Paper presentation at International Seminar
Ar. Murali J., Assistant Professor, School of Architecture successfully presented a research paper in International Seminar on the Topic-Is Bio-mimicry / Biophilia, a viable solution for sustainable Built space / (Architecture)? Mimicking Bio-Chemical process from organism to Building at Dhanalakshmi Srinivasan College of Arts and Science for woman (Autonomous) affiliated to Bharathidasan University, Perambalur, Tamil Nadu, hosted on 15th February 2019
Students win A3 Foundation awards for excellence in architectural design( Futuristic design category) and architectural Journalism
School of Architecture, REVA University is proud to announce that 3 of our students have won under the Journalism and Best Futuristic design category in the National level A3 Foundation awards-2019. The Award function was held on 16 February 2019 at Chandigarh. . This year, Ginelle Lopes, Student of 6th semester, B.Arch was awarded the Prize for Best entry- Journalism category. Aishwarya S. (6th SEM) and Syed Jasim (8th SEM) were awarded Best design in the Futuristic design category. Their entries were selected after a nationwide contest where more than 380 entries were received by the A3 foundation.
Report on Data for INSIGHT APP From Jan 10 2019 to 14 Feb 2019
Rural Documentation Tour to Barkur and Brahmavar for IVth semester B.Arch students
The students of 4th Semester B. Arch were taken on a Rural Documentation study to Barkur and Brahmavar on 18-19 Jan, 2019. The purpose of the trip was to gain an understanding of vernacular architecture in the coastal belt of Karnataka with reference to socio cultural context, planning, architectural character, climate, material availability and construction techniques. The tour concluded with all students getting an insight into the visual character of both locations Barkur and Brahmavar, understanding the surroundings and history related to Barkur and noting the unique vernacular techniques of constructions followed in the different house typologies. The knowledge gained will be documented, analysed and applied for design of a Tourist lodge within the same context. Faculty members Ar. Neeraja Jayan, Ar. Sanjeev Koppar, Ar. Murali J, Ar. Vidya Srikanth accompanied the students on the tour.
Case study visit to IIM Bangalore for VIth semester B.Arch students
A visit to Indian Institute of management, Bangalore was organized on 25 Jan 2019 as a part of curriculum for 6th semester students of Architecture which requires students to study different aspects of campus planning. The IIMB campus was designed by Pritzker Prize winner architect B V Doshi. The campus is a destination and a pilgrimage for students of architecture and practicing architects, with the architecture of the academic and administrative blocks becoming a case study. The visit helped students in understanding the various planning aspects to be considered while designing an institutional campus and integration of various built and un-built spaces. Ar Shama Parween, Ar Kiruthika Selvi, Ar Nazish Abid accompanied the students on the case study visit.
Case study visit to SJBIT, Kengeri for VIth semester B.Arch students
A visit to SJBIT, Kengeri, Bangalore was organized as a part of curriculum for 6th semester students of Architecture which requires students to study different aspects of campus planning on a contoured site. The SJBIT campus was selected as it is located on a contoured site with level differences of almost 5-6m.Almost all the buildings are placed at different levels giving a varied look to the campus. The students were asked to draw sections across the main spine road at different points, and analyze the impact of contours in planning of individual block.
Skill Development Program on Digital 3D making tricks organized by School of Architecture
A skill development program was organized for VIth sem students of B. Architecture on 31st Jan-3rd February 2019 on the theme- Digital 3 D making tricks. Three dimensional digital models are the best way to demonstrate architectural design.. However, making digital 3D model is quite a complicated process and time consuming process. The resource Person, Ar. Ujjal Halder demonstrated various techniques and tricks which can help students deliver good quality drawings within a short span of time.
SDC_Digital 3D
Skill Development Program on Wood cut print by School of Architecture
School of Architecture faculty member Anupama R M. conducted a 3 days Skill development Program – “Wood-cut print” on 8-10 Feb 2019 for the 1st year students of architecture. Students got an opportunity to explore wood by cutting, carving and translating it into an art piece which could be helpful in various interior works. Around 68 students enthusiastically participated in the workshop.
“INQUIZITIVE” architecture quiz organized by LITWITS-School of Architecture Literary Club.
A quiz on Architecture and allied knowledge base was organized for the students of B. Architecture by LITWITS-Literary club of School of Architecture, REVA University on 7th February 2019. Around 60 students from across all semesters participated enthusiastically in the hour long quiz.
Quiz enthusiasts were divided into groups of 3 each and they attempted a total of 30 questions on a wide range of topics related to art and architecture. The students thoroughly enjoyed the quiz and showed great enthusiasm in registering and participating in the quiz.
Site Visit to Chikmaglur for B.Arch 6th Semester students
A visit to Chikmagalur was organized as a part of curriculum for 6th 6semester students of Architecture on 8th and 10th February 2019. A site has been selected in Chikmagalur near Rameshwara lake, where students will be working on design proposals for Campus Planning in the currents semester. Students were taken to the site to study various aspects like Surrounding, history, topography, climatic condition, sensory features, local culture and architecture. Students also visited the Belur and Halebid to study the rock cut architecture of Hoysala dynasty. Faculty members Shama P., Nazish A. And Kiruthika S. accompanied the students for the site visit


Sleep Tracker helps you notice the patterns in your sleep and find the best sleep schedule to optimize your mood.
Sleep is vital to our everyday functioning.
But it can be easy to let your sleep slip off track. Bright lights and bright screens can easily mess with our circadian rhythms, overriding the natural patterns that would normally tell us when to wake up and when to go to bed. Erratic sleep patterns, in turn, can lead to low energy, and an overall decrease in mood.
Sleep Tracker calculates the optimum amount of sleep you should be getting, taking into account your self-reported mood and sleep patterns over several weeks.
Backend Developer
Sophia Jung
Front End Framework Developer
Alexis Hill
Front End Developer
Christopher Harwell
Front End Developer
PJ Wise
Web UI developer
Emily Low


TFTP
Start Daemon:
atftpd –daemon –port 69 /tmp/
Transfer files using the “i” switch:
tftp -i <IP_ADDRESS> GET nc.exe
tftp -i <IP_ADDRESS> PUT network-secret.txt
Note: Most corporate firewalls will block outbound traffic rendering TFTP unusable. TFTP might not be on Windows machines. Files transferred will usually be read only. Change attrib of file to delete using attrib -r filename.
Metasploit, like with FTP, has an auxiliary TFTP server module at auxiliary/server/tftp. Set the module options, including TFTPROOT, which determines which directory to serve up, and OUTPUTPATH if you want to capture TFTP uploads from Windows as well.
Sidenote: Installing TFTP. As I mentioned, TFTP is not included by default on newer versions of Windows. If you really wanted to, you can actually enable TFTP from the command line:
pkgmgr /iu:"TFTP"


Category:Reference Manual
reference
The following fields are allowed in class, module and variant body:
type_member =
field_definition
| property_definition
| event_definition
| method_definition
| type_declaration
field_definition =
Attributes_(ref):attributes Lexical_structure_(ref):IDENTIFIER ':'
Type_expressions_(ref):type [ '=' Expressions_(ref):expr ] ';'
Unless the optional mutable attribute is used,
the field can be modified only inside the constructor.
property_definition =
attributes IDENTIFIER ':' type '{' property_body '}'
property_body =
{ field_definition } 'get' method_body [ 'set' method_body ]
| { field_definition } 'set' method_body [ 'get' method_body ]
The fields defined in a property are local for it, they cannot be
referenced outside the property.
event_definition =
attributes 'event' IDENTIFIER : type '{' event_body '}'
event_body =
'add' Expressions_(ref):block 'remove' block
| 'remove' block 'add' block
interface_member =
[ 'new' ] method_header ';'
| [ 'new' ] 'event' IDENTIFIER ':' type ';'
| [ 'new' ] IDENTIFIER ':' type property_body
Keyword new
is necessary when the declared method hides the
inherited one from another interface.
method_definition =
attributes method_header method_body
This is a definition of method within class or module. Program entry
point is method static Main
.
operator_definition =
attributes method_header method_body
Operator definitions must have the static
attribute. The name
of method must be simply any valid OPERATOR
, which can be then
used (as a prefix or unary operator) on expressions of type specified
by parameters.
method_type_parameters =
'[' IDENTIFIER { ',' IDENTIFIER } ']'
The declaration of a polymorphic method needs its type variables listed
after the identifier.
method_header =
IDENTIFIER [ method_type_parameters ] '(' method_parameters ')' ':'
type [ where_constraints ] method_implements
| 'this' [ method_type_parameters ] '(' method_parameters ')'
This is a declaration of method. Unlike in C#, the type is specified
after the parameters list.
A special method named this specifies a constructor. This declaration
cannot contain the method type and the method has to have type void.
method_implements =
[ 'implements' Expressions_(ref):qualified_identifier
{ ',' qualified_identifier } ]
method_parameter =
[ 'params' ] Expressions_(ref):identifier_or_dummy [ ':' type ]
A method parameter is a pair consisting of identifier or _
and its type specification. Type declaration can be omitted in local
functions definitions.
method_parameters =
[ method_parameters { ',' method_parameter } ]
Method parameters are comma-separated list of parameter specification.
method_body =
';' | block
Body of a method can be empty, or be a block.


Thank you for checking out my website! If you have any questions or want to connect, use one of these methods to reach out!
ryandry1st(at)utexas.edu ryandry1st(at)gmail.com


Used for transmitting developer-defined Analytics events to the Appcelerator Analytics product.
The analytics module can be used to supply additional context or application-specific information which can then be accessed during analysis using Analytics.
Use the featureEvent method to generate custom events that you can view through the Analytics product. You can specify a name for the feature event which is visible through Analytics.
NOTE Although the analytics module allows you to transmit other types of events, such as navigation events and timed events, data regarding these events is not accessible through the Analytics UI.
Navigation events will be supported in a future version of the Analytics product. There is no plan to support the other event types, and they and should not be used.
Sends a generic event for this application session. Not displayed in Analytics UI.
Arguments
| type | [String] | Event type. |
| name | [String] | Event name. |
| data | [Object] | Extra data related to the event. Must be serializable as JSON. |
Sends a feature event for this application session.
Arguments
| name | [String] | Event name, displayed in Analytics UI. |
| data | [Object] | Extra data related to the event, not displayed in Analytics UI. The object must be serializable as JSON. |
Sends a navigation event for this application session. Not displayed in Analytics UI.
Arguments
| from | [String] | String describing the location the user navigated from. |
| to | [String] | String describing the location the user navigated to. |
| name | [String] | Event name. |
| data | [Object] | Extra data related to the event. The object must be serializable as JSON. |
Sends a settings event for this application session. Not displayed in Analytics UI.
Arguments
| name | [String] | Event name. |
| data | [Object] | Extra data related to the event. Must be serializable as JSON. |
Send a timed event for this application session. Not displayed in Analytics UI.
Arguments
| name | [String] | Event name. |
| start | [Date] | Event start as a Date object. |
| stop | [Date] | Event end as a Date object. |
| duration | [Number] | Event duration. |
| data | [Object] | Extra data related to the event. Must be serializable as JSON. |


Welcome to our Harvard University, Fall 2017 - Data Science I final project page. Please use the
menu button below to jump to your section of choice.
Toggle Menu
The purpose of this project is to use publicly available data through Spotify's API, the Spotipy python library, word-to-vector feature engineering, and celebrity information to predict the success of Spotify user playlists, and create a tool to build successful playlists based on user specified features (genre, artist, etc.).
Throughout this project "playlist success" (our response variable) is defined as the number of playlist followers. We have employed machine-learning regression techniques taught throughout the semester as well as Word2vec modeling to predict playlist success.
In this section we will give you some insights in to the data we collected, aggregated, and combined, as well as the in-depth exploratory data analysis (EDA) performed to try and illustrate relationships surrounding playlist success - specifically artist categorization, artist and playlist genres, and playlist popularity as it relates to time.
Baseline Data:
Baseline data was collected primarily from the Spotify API. After
sourcing the Spotify users who “own” (the playlists are attached to their accounts) a large
number of playlists, the spotipy library was employed to collect user playlists, tracks, user
followers, and genre data from the API, each saved as JSON files. Genre information for
each playlist was harder to source and incorporate than one would think. It does not come
directly from each playlist, but rather from the artists of each track as a separate query. We
also collected celebrity names from US
Magazine.
Before combining into one comprehensive DataFrame, the separate files have the following basic form:
| Data File | Observations | Features |
|---|---|---|
| Usernames | 846 | 1 |
| Celebrity Names | 840 | 1 |
| Genres | 1343 | 5 |
| Playlists | 8183 | 7 |
| Tracks | 367911 | 8 |
The files were combined and manipulated into a single DataFrame via the playlist ID, username, and artist name attributes. While cleaning, we decided to eliminate any playlist with one or fewer followers (the owner).
We explore the data (and our engineered features) at both the track and the playlist level. As you can see above, we have about 9.7 playlists per user when we include all users. When we drop playlists with below 1 follower, we have about 4.4 playlists per user. Likewise, we start with ~368k tracks and after we drop the playlists with if they have one or fewer followers we only have ~211k tracks remaining.
This is clearly a biased subsample of playlists in that we sourced users that own high numbers of playlists and removed those playlists with only one follower, but the flipside is that the vast majority of Spotify users are only making playlists for themselves (one user), or maybe sharing them with just friends or close loved ones. A cross-section of those users would make our already right-skewed (as seen below) data even more skewed.
Click here to explore our data collection techniques.
Playlist Followers - A first look at playlist success:
Engineering features around artist and playlist data yielded interesting relationships. A
cursory measure of playlist success, our generalized project goal, is the number of followers
per playlist. The distribution of playlist followers shows a significant right-skew, with most
playlists having few followers and a few approaching the 1M mark. The log-transform of followers
illustrates a potentially more useful response variable (right).
Categorizing artists:
We further aggregated the artists by splitting them up into five distinct categories using
combinations of their mean popularity (as determined by Spotify's popularity metric) and total
number of artist tracks as seen in the following table.
The motivation for the class boundary decisions was to keep the class numbers down to reasonably
small levels, but still explain the variance in artist performance. The 10-track boundary was
selected due to the shape of the data - it was designed to catch the slight nonlinearity in
artist success rates as they produce fewer songs. Then, the popularity boundaries were set to be
reasonably symmetrical around the normal curve while ensuring that each class had a significant
number of observations present.
These categories should be
self-descriptive, but the two plots below do a fantastic job of illustrating each in terms of
their thresholds and relationships. The artist popularity metric ties in with our expectations
because we see people like Post Malone, Camila Cabello, and Ed Sheeran in our superstar
category.
| Artist Category | Artist Mean Track Popularity | Artist Total Tracks | Number of Tracks in Sample Produced by class |
|---|---|---|---|
| Superstar | >= 50 | >= 10 | 60k |
| Star | >= 20 and < 50 | >= 10 | 62k |
| One-hit-wonder | >= 40 | < 10 | 27k |
| Garage Band | < 40 | < 10 | 45k |
| Trash Factory | >= 0 and < 20 | >= 10 | 14k |
Continuing Artist Analysis:
Below you can see a illustrative distribution of these five artist categories grouped by
playlist as they relate to number of playlist followers and specific track popularity (as
determined by Spotify). We see
that, unsurprisingly, not only do most playlists incorporate popular artists (superstar:blue
and star:red), but a
lot of them have the superstar artists’ best songs (the mostly blue right side), as well as a
smattering of one-hit-wonders (green in the middle) and a dense area of moderately popular songs
throughout (between 30 and 70 popularity). This relationship and playlist architecture should
be intuitive. You can also note, interestingly, that only one-hit-wonders (green) get perfect
100s for
track popularity.
Playlists & Time:
It appears that there may be a relationship between the number of tracks a playlist has and its
number of followers (top-left), as well as length of its description (top-right). We also
investigated the impact of playlist turnover rate, or relative age, days between the oldest and
newest track being added (bottom-left), as well as the age of the oldest song on playlist
follower count (bottom-right).
Track Popularity:
We also took a closer look at other playlist metrics, specifically average playlist track
popularity versus the number of tracks in a playlist or the maximum playlist track popularity as
seen in the following two plots, respectively. Does it matter more to have a few really popular
songs, or just a lot of decent songs? From our graphs below we would say having a few good songs
is more important. The graph on the right below shows the average playlist track popularity and
the max track popularity colored by playlist followers. We can see the playlists with lots of
followers (dark blue) are much more consistently in the section with high max track popularity
regardless of their mean track popularity.
Genres:
If you were to ask anyone on the street how they would measure the success of any playlist, one
of their first responses would probably be "Depends on the genre." This is a natural
categorization we do with music on a daily basis. It is typically how we choose what we are
going to listen to when we go to the gym, start our daily commute, or go for a hike in the
woods, so of course the predominant genres that make up a playlist will have some impact on the
relative success of that playlist against all others, as well as those geared toward the same
genre.
In this section you will see four distinct looks at how genres, at the artist, playlist,
and track levels, impact playlist success.
Artist Genres - The top-left barplot shows the median number of playlist followers, so as
to be less sensitive
to outliers.
The top-right barplot is based on mean artist popularity by genre. As you can
see, there are some specific genres at the top that we would usually associate with one artist
(canadian pop - Justin Bieber, detroit hip hop - Eminem). It is likely those artists are skewing
the distribution, since those are their respective genres. Sadly, we do not have enough members
of each genre to get a good view of the most popular genres by artist.
Playlist Genres - The bottom-left barplot look at the most common genre by number of
playlist occurrences. Here we use the "mode genre" field. This field is made by looking at all
the genres that make up a playlist (on a track level) and choosing the most common (mode).
Track Genres - The bottom-right barplot takes a look at some "genre-type"
information. We are specifically looking at any sub-genres that fall in a larger, more
general genre. For example, 'classic rock', 'heavy rock', and 'swedish electronic pop rock'
would all fall in our 'rock' genre-type. For each genre related to a song we have binary
variables to indicate whether that genre-type is present in the track. The genres in this plot
represent the 15 most common genres in our dataset [alternative, Christmas, country, dance,
deep, hip hop, house, indie, jazz, latin, metal, pop, rap, rock, soul].
Note: We decided to use the top 15 genres since this corresponds to industry
standards for categorizing music. For example, iTunes "search-by-genre" has twenty-two and
Billboard 200 uses ten.
Celebrity Playlist Owners:
Lastly, we explored whether the owner of the playlist is an official spotify account. The
motivation for
this is that some of the most popular playlists we have seen have been from a celebrity's
official
Spotify account, and that generally celebrity accounts (such the Official Justin Bieber account)
tend to produce more followers. We would like to be able to account for this bias.
As you can see, there are not a huge number of celebrities in our data, but their social status inevitably has an impact on playlist popularity.
Click here for a closer look at our EDA techniques.
A major contributing source for developing our 209-level feature using word-to-vec (w2v) analysis of playlist titles was this paper (Mikolov, Chen, Corrado, & Dean, 2013) entitled "Efficient Estimation of Word Representations in Vector Space." The paper abstract follows:
We propose two novel model architectures for computing continuous vector representations of words from very large data sets. The quality of these representations is measured in a word similarity task, and the results are compared to the previously best performing techniques based on different types of neural networks. We observe large improvements in accuracy at much lower computational cost, i.e. it takes less than a day to learn high quality word vectors from a 1.6 billion words data set. Furthermore, we show that these vectors provide state-of-the-art performance on our test set for measuring syntactic and semantic word similarities.
Baseline Modeling:
As we move into modeling and attempting to predict playlist success based on number of
followers, we again use the playlists (and related tracks) that have more than one follower. The
rational being that we do not want to use data that could skew the popularity metrics for tracks
if it is unlikely that those users have any followers that could potentially follow their
playlist. Essentially, we do not think those users have enough presence on Spotify for the
number of followers to be a meaningful feedback metric for playlist success. This left us with
a DataFrame consisting of 210,798 observations (tracks) across 49 measures, but since we are
predicting playlist followers and do not have time or experience to implement a full
hierarchical model, we aggregate our track, artist, and user information up to the playlist
level.
Imputation:
We also changed our datetime format columns to just include the year, and we median impute for
the (few) missing values in other columns. We used the median since there were few values to
impute and the distributions are skewed as seen in the first followers plot above, hence mean
imputation would be susceptible to outliers.
One hot encoding and train/test split:
Since we have a number of categorical measures, one hot encoding was applied to those features.
We also grouped tracks by playlist, reducing our observations from about 210,000 to a
DataFrame with ~3500 playlists across 480 features.
We split the data with 75% in the training set and 25% in test, standardized the numerical columns, then took an iterative approach to modeling, using 5-fold cross-validation throughout, and moved through eight different regression techniques: ridge, lasso, elastic net, k-NN, random forest, AdaBoost, XGBoost, and SVM.
Word2vec on Playlist Names:
In order to go beyond the scope of 109A and incorporate a method not discussed in class, we
decided to apply a word-to-vec (w2v) transform to as many applicable words as there are in
the set of playlist names. The core intuition being that the playlist name is what represents
the playlist to the outside world. A bad playlist name can keep people from following or
listening to it, even if the content is great, while a good playlist name can draw users. The
playlist name also, hopefully, categorizes the playlist in a meaningful way we can use. This
categorization could be by genre, mood, activity or any other type of category the playlist
creator thought was useful.
Click here to explore the w2v model training and implementation specific to our project.
W2V Technique:
By using word-to-vec we seek to cluster the playlist names into meaningful categories based on
the normalized sum of the vectors of known words in the playlist. This will aggregate the vector
information from each word in the playlist description, with all unknown words set to the zero
vector. We normalize the vectors in one feature (we have a normalized and a not normalized
version of this feature) once we aggregate them to stop playlists with just many words from
being higher in magnitude than playlists with just a few words.
W2V Difficulties:
Ultimately, there will be some difficulties with misspellings, different languages, and internet
slang (or emojis), and we will doubtless lose information in this quick application of w2v, but
we think the output will still be a meaningful feature in our final model. We have corrected for
many of these as was quickly possible with some simple NLTK and regex tools.
W2V Model:
Our w2v model was trained with the Text8 wikipedia corpus. This corpus seemed to be the
most applicable one that was both a reasonable size to download to a personal computer and took
a reasonable amount of time to train. After training the model, the "sentences" formed
by the playlist names were added to the vocabulary of the model. Without proper
context the model will not denote a vector transform for a word, so there are still several
words (about 25%) that do not have a related vector representation.
About 84% of the playlist names have at least one meaningful word (not a stop word by NLTK standards) that has a vector representation in our model. This number could doubtless be improved with a music specific or more casual internet chat area like Twitter or Reddit dataset as opposed to the more formal Wikipedia dataset, but there is only so much time to make our features.
The below plot shows different word locations in a sample of our TSNE plot. There is some structure to the word placement. Toward the bottom, there are several spanish words and related genres (like salsa and classicos). We can also see some other consistencies, like "kendrick" and "hip hop" are together in one group, and "party", "club" and "pill" are all together in another group. The w2v transform is definitely noisy in this case though. We think this is due to the smaller training set, and the makeup of the training set. The training set is made up of wikipedia documents which, though they contain a lot of words, probably do not have a lot of the same contexts or slang that we will see here. If we could train with a corpus from Twitter or Reddit we might have had better context for the slang and pithy statements we often see in playlist names.
Model Selection without w2v:
We iterated over several regressor models (with each parameter set optimized by 5-fold
cross-validation) to determine which performs best with this data both without the w2v
feature included. Find the results to the right.
Note: We did not include Linear Regression for two reasons:
We can see in these results that the best performing model on a cross-validated training set is our random forest with 500 estimators.
| Model | Cross-validated validation set R^2 mean & std (5-folds) |
Train Score | Test Score |
|---|---|---|---|
| Ridge Regression | -0.0003, 0.0591 | 0.0513 | 0.0353 |
| Lasso Regression | -0.0241, 0.0441 | 0.0840 | 0.0412 |
| Elastic Net Regression | -0.0028, 0.0625 | 0.0876 | 0.0409 |
| Random Forest Regression | 0.0522, 0.0424 | 0.8766 | 0.1441 |
Model Selection with w2v:
We iterated over several regressor models (with each parameter set optimized by 5-fold
cross-validation) to determine which performs best with this data both with the w2v
feature included. Find the results to the right.
We can see in these results that the best performing model on a cross-validated training set is our random forest with 500 estimators.
| Model | Cross-validated validation set R^2 mean & std (5-folds) |
Train Score | Test Score |
|---|---|---|---|
| Ridge Regression | -0.0001, 0.0606 | 0.0513 | 0.0353 |
| Lasso Regression | -0.0302, 0.1113 | 0.0854 | 0.0414 |
| Elastic Net Regression | -0.0028, 0.0625 | 0.0884 | 0.0410 |
| k-NN Regression | 0.0133, 0.0144 | 0.0923 | 0.0448 |
| Random Forest Regression | 0.0635, 0.0404 | 0.8786 | 0.1047 |
| AdaBoost Regression | -0.0269, 0.0441 | 0.7277 | 0.0897 |
| XGBoost Regression | -0.0631, 0.2525 | 0.4715 | 0.1106 |
| SVM Regression | 0.0502, 0.0144 | 0.1613 | 0.0632 |
Feature Selection:
Before moving on to the results and playlist generation, let's take a quick look at feature
selection.
We can see above that the best performing model on a cross-validated training set is our random forest with 500 estimators. We will use that as our baseline model - but we note that some over-fitting occurs on the training set. We believe this is due to the high number of features (some of which are codependent). So next, we try to reduce the feature set overall and see if this leads to an increase in model performance.
The 30 most common features below are generally consistent with our expectations - for example:
Note that certain features here do have elements of multicollinearity - for example, we have
created features user_f_mean, user_f_min, and user_f_max, which correspond to the average,
smallest, and largest subscriber numbers of all of the user's playlists. As a next step, we had
contemplated removing certain highly correlated features. However, as we can see below, model
performance on a cross-validated training set is generally worse
with a reduced feature set (vs. our full feature set).
So we will keep our baseline
model and our original random forest
regressor when we add in the w2v feature, without adjusting for multi-collinear features. Our
rationale here is that while min/max/mean features are partially correlated, each does add
unique predictive information. And empirical results show that our full set achieves superior
R2 values, so we feel comfortable proceeding with the random forest model on a
full feature set.
| Model | Cross-validated validation set R^2 mean & std (5-folds) |
Train Score | Test Score |
|---|---|---|---|
| Ridge Regression | -0.0013, 0.0603 | 0.0506 | 0.0350 |
| Lasso Regression | -0.0312, 0.1104 | 0.0836 | 0.0404 |
| Elastic Net Regression | -0.0029, 0.0626 | 0.0742 | 0.0420 |
| k-NN Regression | 0.0213, 0.0011 | 0.0959 | 0.0485 |
| Random Forest Regression | -0.0257, 0.1805 | 0.8755 | 0.1292 |
| AdaBoost Regression | 0.0555, 0.0143 | 0.6542 | 0.0671 |
| XGBoost Regression | -0.0661, 0.2469 | 0.4604 | 0.0988 |
| SVM Regression | 0.0445, 0.0323 | 0.0871 | 0.0502 |
Modeling without the w2v feature:
| Model | Train Score | Test Score |
|---|---|---|
| Ridge Regression | 0.0485 | 0.0335 |
| Lasso Regression | 0.0798 | 0.0390 |
| Elastic Net Regression | 0.0811 | 0.0390 |
Modeling with the w2v feature:
| Model | Train Score | Test Score |
|---|---|---|
| Ridge Regression | 0.0488 | 0.0335 |
| Lasso Regression | 0.0813 | 0.0392 |
| Elastic Net Regression | 0.0729 | 0.0413 |
The additional clustering from our w2v feature does not add much to the model as a whole when all predictors are considered. This is likely for two reasons:
As seen to the right, the average improvement in score for each model with the w2v feature is 2.147%. This implies that the reason our w2v feature does not add predictive power could be due to confounding variables already in the model.
Please hold your applause until the end, and see the "Results, Conclusions, and Future Work" section below for analysis.
Generating Playlists:
Aside from modeling playlist success we also developed a model to generate a playlist of a
user-defined length and user-specified genre within the top 15 genres: alternative, christmas,
country, dance, deep, hip hop, metal, house, indie, jazz, latin, pop, rap, rock, and soul.
The model works by using our predictive model to predict a score for a playlist, and then joining this with the unique track playlist combos. Then we aggregate up to individual track id's, summing up the playlist scores. Once we are here, we have the data we need.
Now, when we run the generative model, we get just tracks that are related to the specified genre, and treat that as a distribution to sample from. We then normalize the predicted "scores" from our model and scale them so they are valid probabilities.
Finally we sample from the distribution of the songs in our genre with the associated probabilities given to them by the model. A sample "Latin" 20-song playlist is found to the right.
Note: Each song can possibly be found in multiple genres.
Results:
The top models we looked at were random forest without our one hot encoded w2v feature, XGBoost
with all the predictors, and SVM regression with all the predictors.
The best performing model for predicting Spotify playlist success was random forest regression, which achieved an R2 on the test set of 14.4%. We considered sqrt(n) features when looking for the best split at each tree, where n was the total number of predictors we used in fitting the model. Using cross-validation, we determined that the optimal number of trees for the forest was 500. We were able to leave the maximum depth of the trees unbounded without shouldering prohibitive computational costs. The second-best performing model was the “Extreme Gradient Boosting” (XGBoost) algorithm with an R2 on the test set of 11.1%. Using cross-validation to tune the hyperparameters, we set the model’s maximum depth to 3 and number of estimators to 25. We chose the Random Forest over the XGBoost model because it had a higher mean CV score. This implies the model in general was more consistent in its performance on the validation set, and hopefully more generalizable. SVM Regression is in our top three not due to its high R2, but due to its consistency. Its R2 was only 6.3% on the test set, but the mean CV score was very close to this value and the std of CV scores was also low. In addition, the training performance was not outrageously larger than the test performance, indicating the model is generalizing well from train to test.
Conclusions:
For a research domain as complex as an individual’s music preferences and the influence of the
broader music industry on track popularity, our results were strong. Through the
R2 results, we can conclude that our best performing model managed to account
for more than 14% of the variation in the number of playlist followers (about the mean). Random
Forest and XGBoost are foundational tools in the machine learning context, generally regarded as
relatively strong performers in problems where there are many predictors, of which many are
considered significant. In the context of the high level of complexity in this problem, it is
not surprising that these models performed the best.
With the word-to-vec (“w2v”) feature we used as our 209-level feature, we can conclude that our hypothesis was somewhat true in that there is minor improvement in the predictive power of relatively simpler models (Ridge, Lasso) when they incorporate the feature than when they don’t. When incorporating our 209-level w2v feature we see the average test set score improve by 2.147% in these models, when we control for the confounding variables. We expected that a playlist’s name would be a decent proxy for the playlist’s contents, and the results of incorporating our w2v feature shows signs this hypothesis could be true. One hypothesis as to why there isn’t any meaningful improvement in the more complex models (random forest, XGBoost) is that through their ensemble and bagging algorithms, all the information contained in our word-to-vec feature is captured by some combination of the other predictors. For example, the w2v representation may be strongly related to the distribution of genres (i.e., the type of music in a playlist), which is what our hypothesis about the playlist names was based on.
This is a difficult question to investigate, and it is one compounded by the weak interpretability of random forest and XGBoost models. Yet, what we sacrificed in interpretability, we compensated for with improved predictive power. Since the main goal of the project was to build the most effective model at predicting playlist success rather than making inferences on what are the primary drivers, we are fine to accept the added complexity and lower interpretability of these models compared to the others we evaluated.
Future Work:
To improve the w2v feature and give it a more “fair” examination, we could look to train the w2v
transform on a corpus more reflective of the semantics in Spotify’s playlist names. Out of
convenience and computational constraints, we used the Wikipedia corpus. However, as noted in
the w2v section, only about 84% of the playlist names have at least one meaningful word (not a
stop word by NLTK standards) that has a vector representation in our model. To improve this and
consequently better explain the sample set of playlist names, we could look to see whether a
more music-specific or more casual internet chat area (e.g., Twitter or Reddit) dataset is
available with which to train the w2v transform.
The playlist generation model works great in notebook form. If given more time, and requisite expertise, another feature of this project we would have liked to incorporate is a kind of "webapp" where the reader could choose one of our predefined genres from a dropdown menu to generate a playlist. Again as it stands, using the final project notebook works quite well.
Lastly, the model would likely benefit from incorporating other datasets pertaining to music, artists and genres. Currently, our model is fit on predominantly Spotify-sourced data. One challenge in this regard is that many other available datasets (such as the Million Song Dataset) are skewed towards older (what some may consider more “classic”) tracks, whereas Spotify’s playlists contain many recent tracks. In fact, Spotify prides itself on its ability to serve as a source for aspiring artists to be heard. Therefore, we weren’t able to include information from the Million Song Dataset because limiting our domain to songs where there was overlap between Spotify and the Million Song Dataset would have significantly shrunk our playlist domain.
This project was produced by the following students:


teh prggmr's website
Down below you can find my latest postings, some of the projects I hax away at and
some more info about me ... if your interested.
Find me on Github Forrst Twitter LinkedIn
stories i decided to post on the interwebs
I haven't written anything yet though!


Where can you see yourself working as a programmer?
Would you prefer to take class in Portland, Or, Seattle, Wa or online?
Are you ready to commit a huge amount of time and energy into learning to code?
Are you interested in learning how to program?
Are you looking to make friends?
You should take C#/.NET
You should take Java/Android
You should take PHP
You should take Ruby/Rails


Salmon Cookies
Our locations
Some Of Our Side Products
Contact
We offer full-service for any event, large or small. We understand your needs and we will cater the food to satisfy the biggerst criteria of them all, both look and taste. Do not hesitate to contact us.
We open 14 hours every day from 6am until 7pm
salmon cookies, 42nd Living St, 43043 Seattle
salmon cookies, 42nd Living St, 43043 Dubai
salmon cookies, 42nd Living St, 43043 Tokyo
salmon cookies, 42nd Living St, 43043 Lima
salmon cookies, 42nd Living St, 43043 Paris
You can also contact us by phone 00553123-2323 or email<EMAIL_ADDRESS>, or you can send us a message here:


XTween - Tweener for Unity
Created by Lee Dong-Myung(Toki-Labs)
XTween?
XTween is Tweener library for unity using by code, It has powerful performance and easy to implement.
XTween is
- Can make tweener by few code (easy to learn and good readablity)
- Provide code hint. (You just start with ?To? than You can use tweener)
- Easy to control event. (Support Anonymous Method)
- Support coroutine. (Easy to combine with other instruction)
- Support custom easing.
- Can make instance. This good at resuablity and time control.
- Less use of memory and cpu. (XTween is don?t create MonoBehaviour each by tween)
- Support in editor mode(Not Play mode) and Available on all types of platforms
You can check example at XTween Example
Ps. Because it is still in the development stage(ALPHA), the interface can change frequently. At this stage, you can use it for testing purposes. After in BETA, You can use it stably.
Implementation
// Shortcut type
gameObject.ToPosition2D(600f, 200f, 1f).Play();
// Universal type
XTween.To(gameObject, XHash.Position(600f, 200f), 1f).Play();
// Use with coroutine
StartCoroutine(CoroutineTween());
IEnumerator CoroutineTween()
{
yield return XTween.To(gameObject, XHash.Position(600f, 200f), 1f).WaitForPlay();
//or
yield return gameObject.ToPosition2D(600f, 200f, 1f).WaitForPlay();
}
Lastest Release
Version(Alpha) 0.0.115 - XTween_0.0.115.unitypackage
Performance
Tweener comparison when moving 1000 gameObjects. set x, y, z and use elastic easing.
Garbage Alloc
Start
XTween rarely produces Garbage
End
XTween dose not produces garbage.
CPU Performance
XTween is similar with D Tween, but 2 times faster than i Tweener.
Gabage Alloc Time/Cost XTween D Tween L Tween I Tween Start 122B 0.6MB 406.4KB 4.7MB End 0B 0B 0B 169.9KB Update 0.8ms 0.8ms 1.2ms 1.7ms Total 122B/0.8ms 0.6MB/0.8ms 406.4KB/1.2ms 4.9MB/1.7ms XTween does not produce Garbage because it uses Pooling. and XTween is good performance at cpu.
Code Compare
Other Tweener Code
XTween Code
Road Map
- Support property tween
- Support UI RectTransform
- Performance check & polishing effciency
- Support Easing Edit in UI Graph
- Stabilize Interface
- Decorator Combine with IXTween Interface
- Documentaion
- Specific examples
- Support visual editor
- Support path editor by GUI
Position
gameObject.ToPosition2D(600f, 200f, 1f).Play();
//Universal type
XTween.To(gameObject, XHash.New.AddX(600f).AddY(200f).AddZ(100f), 1f).Play();
Scale
gameObject.ToScale2D(1f, 1.5f, 1f).Play();
//Universal type
XTween.To(gameObject, XHash.New.AddScaleX(1f).AddScaleY(1.5f).AddScaleZ(0.5f), 1f).Play();
Rotation
gameObject.ToRotation3D(60f, -180f, -45f, 1f).Play();
//Universal type
XTween.To(gameObject, XHash.New.AddRotationZ(600f), 1f).Play();
Combination
//Position, Scale, Rotation tween in same time, same easing
gameObject.To(XHash.Position(0f,10f).AddScaleX(200f).AddRotationZ(60f), 1f).Play();
//Universal type
XTween.To(gameObject, XHash.New.AddX(600f).AddScaleX(200f).AddRotationZ(180f), 1f).Play();
Bezier
XHash hash = XHash.Position(0f,0f).AddControlPointX(1000f).AddControlPointZ(-500f);
gameObject.To(hash, 1f).Play();
//Universal type
XTween.To(gameObject, hash, 1f).Play();
Value
//Setter
XTween.ToValue(x=>camera3D.fieldOfView=x, 10f, 1f).Play();
//or Multi value type
XObjectHash hash = XObjectHash.New.Add("value0", 50f, 10f).Add("value1", 0f, 10f);
XTween.ToValueMulti(hash, UpdateValue, 1f).Play();
void UpdateValue(XObjectHash hash)
{
camera3D.fieldOfView = hash.Now("value0");
Debug.Log( hash.Now("value1") );
}
Property
camera3D.ToProperty("fieldOfView", 6f, 1f).Play();
Event Handling
gameObject.ToPosition2D(600f, 200f, 1f)
.AddOnComplete(()=>Debug.Log("OnComplete")).Play();
void OnTweenEnd(GameObject tweenTarget)
{
Debug.Log(value);
}
Coroutine
Support use with coroutine
//Start tween
IEnumerator tweenCoroutine = CoroutineTween();
StartCoroutine(tweenCoroutine);
IEnumerator CoroutineTween()
{
yield return gameObject.ToPosition3D(200f, 50f, -1500f, 1f).WaitForPlay();
Debug.Log("On Complete First Tween");
//Start other tween start at 0.3sec
yield return gameObject.ToPosition2D(100f, 500f, 1f).WaitForPlay(0.3f);
Debug.Log("On Complete Second Tween");
}
//Stop tween;
StopCoroutine(tweenCoroutine);
Serial
XTween.SerialTweens
(
false,
gameObject.ToPosition2D(1000f, 300f, 1f),
gameObject.ToScale2D(200f, 200f, 1f)
).Play();
Parallel
XTween.ParallelTweens
(
false,
gameObject.ToPosition2D(1000f, 300f, 1f),
gameObject.ToScale(200f, 200f, 1f)
).Play();
UI
XHash hashButton = XHash.New.AddX(400f).AddY(-250f).AddWidth(800f).AddHeight(400f);
XTween.To(button, hashButton, 1f).Play();
//or when stretch type
XHash hashDropdown = XHash.New.AddLeft(2000f).AddRight(300f).AddTop(500f).AddBottom(400f);
XTween.To(dropdown, hashDropdown, 1f).Play();
Color
XTween.ToColor(sprite, XColorHash.New.AddRed(0.56f).AddGreen(0.83f), 1f).Play();
//or when object has other type
XColorHash hash = XColorHash.New.AddRed(0.56f).AddGreen(0.83f);
XTween.ToColor<Image>(imageInstance, "color", hash, 1f).Play();
Easing
gameObject.ToPosition2D(600f, 200f, 1f, Ease.QuintOut).Play();
Custom Easing
Customizable Easing, Support code hint for use of ease name, TopMenu -> Windows -> XTween Editor
XHash hash = XHash.Position(200f, 50f, -1500f)
.AddControlPointX(-1000f,550f).AddControlPointY(550f,-300f);
XTween.To(target3D, hash, 1f, Ease.Custom(EaseCustom.MyEasing)).Play();
Decorator
IXTween tween = XTween.ToColor(sprite, XColorHash.New.AddRed(0.56f).AddGreen(0.83f), 1f);
//Delay Tweener
tween.SetDelay(tween, 1f/*Pre Delay*/, 1f/*Post Delay*/);
//Scale Tweener time
tween.SetScale(tween, 2f/*Scale tweener time*/);
//Repeat Tweener
tween.SetRepeat(tween, 3/*3 time repeat*/);
//Reverse Tweener
tween.SetReverse(tween);
tween.Play();
Reuse
XTween is basically autodispose. when the tweener is completed or stopped. So, you should set to ?Lock? for reuse tweener
//This Tweener will not dispose when stop or complete.
IXTween tween = gameObject.ToPosition2D(600f, 200f, 1f).SetLock().Play();
//When the tweener after completed or stopped. You can reuse this.
tween.Play(0f); //Replay
//When you are not using twin anymore. You should "Release" this tween.
tween.Release();
tween = null;
Time Control
//Start
IXTween tween = gameObject.ToPosition2D(600f, 200f, 1f).Lock().Play();
//Stop at this position
tween.Stop();
//Resume
tween.Play();
//Move to 0.5sec and Stop
tween.GotoAndStop(0.5f);
//Move to 0.3sec and play;
tween.Play(0.3f);
//Position set to 0 and Stop
tween.Reset();
Author Info
Lee Dong-Myung(Tok-Labs) is a software developer in Korea.
Blog: http://blog.toki-labs.com (Korean) Mail<EMAIL_ADDRESS>License
This library is under the MIT License.
Some code is borrowed from BetweenAS3.


If unchecked, plugin will resubmit the job if it failed due an instance termination. For example, after an EC2 Spot instance interruption. If checked, auto resubmit will be disabled.
Interrupted job will be shown as failed or aborted see pipeline notes below. While copy will be submitted into jenkins queue to execute or any possible node.
Parametrized job will be resubmitted with same parameters as defined for interrupted.
In case if job is pipeline (workflow) interrupted task will be aborted as workflow usually don't fail in case of node interruption and wait until node will be online. Plugin force job to abort and resubmit.
Please report any problem with this feature to GitHub Issue