DistCp Version 2 (distributed copy) is a tool used for large inter/intra-cluster copying. It uses MapReduce to effect its distribution, error handling and recovery, and reporting. It expands a list of files and directories into input to map tasks, each of which will copy a partition of the files specified in the source list.
The erstwhile implementation of DistCp has its share of quirks and drawbacks, both in its usage, as well as its extensibility and performance. The purpose of the DistCp refactor was to fix these shortcomings, enabling it to be used and extended programmatically. New paradigms have been introduced to improve runtime and setup performance, while simultaneously retaining the legacy behaviour as default.
This document aims to describe the design of the new DistCp, its spanking new features, their optimal use, and any deviance from the legacy implementation.
The most common invocation of DistCp is an inter-cluster copy:
bash$ hadoop distcp hdfs://nn1:8020/foo/bar \ hdfs://nn2:8020/bar/foo
This will expand the namespace under /foo/bar on nn1 into a temporary file, partition its contents among a set of map tasks, and start a copy on each NodeManager from nn1 to nn2.
One can also specify multiple source directories on the command line:
bash$ hadoop distcp hdfs://nn1:8020/foo/a \ hdfs://nn1:8020/foo/b \ hdfs://nn2:8020/bar/foo
Or, equivalently, from a file using the -f option:
bash$ hadoop distcp -f hdfs://nn1:8020/srclist \ hdfs://nn2:8020/bar/foo
Where srclist contains
hdfs://nn1:8020/foo/a hdfs://nn1:8020/foo/b
When copying from multiple sources, DistCp will abort the copy with an error message if two sources collide, but collisions at the destination are resolved per the options specified. By default, files already existing at the destination are skipped (i.e. not replaced by the source file). A count of skipped files is reported at the end of each job, but it may be inaccurate if a copier failed for some subset of its files, but succeeded on a later attempt.
It is important that each NodeManager can reach and communicate with both the source and destination file systems. For HDFS, both the source and destination must be running the same version of the protocol or use a backwards-compatible protocol; see Copying Between Versions.
After a copy, it is recommended that one generates and cross-checks a listing of the source and destination to verify that the copy was truly successful. Since DistCp employs both Map/Reduce and the FileSystem API, issues in or between any of the three could adversely and silently affect the copy. Some have had success running with -update enabled to perform a second pass, but users should be acquainted with its semantics before attempting this.
It’s also worth noting that if another client is still writing to a source file, the copy will likely fail. Attempting to overwrite a file being written at the destination should also fail on HDFS. If a source file is (re)moved before it is copied, the copy will fail with a FileNotFoundException.
Please refer to the detailed Command Line Reference for information on all the options available in DistCp.
-update is used to copy files from source that don’t exist at the target or differ from the target version. -overwrite overwrites target-files that exist at the target.
The Update and Overwrite options warrant special attention since their handling of source-paths varies from the defaults in a very subtle manner. Consider a copy from /source/first/ and /source/second/ to /target/, where the source paths have the following contents:
hdfs://nn1:8020/source/first/1 hdfs://nn1:8020/source/first/2 hdfs://nn1:8020/source/second/10 hdfs://nn1:8020/source/second/20
When DistCp is invoked without -update or -overwrite, the DistCp defaults would create directories first/ and second/, under /target. Thus:
distcp hdfs://nn1:8020/source/first hdfs://nn1:8020/source/second hdfs://nn2:8020/target
would yield the following contents in /target:
hdfs://nn2:8020/target/first/1 hdfs://nn2:8020/target/first/2 hdfs://nn2:8020/target/second/10 hdfs://nn2:8020/target/second/20
When either -update or -overwrite is specified, the contents of the source-directories are copied to target, and not the source directories themselves. Thus:
distcp -update hdfs://nn1:8020/source/first hdfs://nn1:8020/source/second hdfs://nn2:8020/target
would yield the following contents in /target:
hdfs://nn2:8020/target/1 hdfs://nn2:8020/target/2 hdfs://nn2:8020/target/10 hdfs://nn2:8020/target/20
By extension, if both source folders contained a file with the same name (say, 0), then both sources would map an entry to /target/0 at the destination. Rather than to permit this conflict, DistCp will abort.
Now, consider the following copy operation:
distcp hdfs://nn1:8020/source/first hdfs://nn1:8020/source/second hdfs://nn2:8020/target
With sources/sizes:
hdfs://nn1:8020/source/first/1 32 hdfs://nn1:8020/source/first/2 32 hdfs://nn1:8020/source/second/10 64 hdfs://nn1:8020/source/second/20 32
And destination/sizes:
hdfs://nn2:8020/target/1 32 hdfs://nn2:8020/target/10 32 hdfs://nn2:8020/target/20 64
Will effect:
hdfs://nn2:8020/target/1 32 hdfs://nn2:8020/target/2 32 hdfs://nn2:8020/target/10 64 hdfs://nn2:8020/target/20 32
1 is skipped because the file-length and contents match. 2 is copied because it doesn’t exist at the target. 10 and 20 are overwritten since the contents don’t match the source.
If -update is used, 1 is overwritten as well.
This section only applies to HDFS.
If the target and all of the source pathnames are in the /.reserved/raw hierarchy, then ‘raw’ namespace extended attributes will be preserved. ‘raw’ xattrs are used by the system for internal functions such as encryption meta data. They are only visible to users when accessed through the /.reserved/raw hierarchy.
raw xattrs are preserved based solely on whether /.reserved/raw prefixes are supplied. The -p (preserve, see below) flag does not impact preservation of raw xattrs.
To prevent raw xattrs from being preserved, simply do not use the /.reserved/raw prefix on any of the source and target paths.
If the /.reserved/raw prefix is specified on only a subset of the source and target paths, an error will be displayed and a non-0 exit code returned.
| Flag | Description | Notes |
|---|---|---|
| -p[rbugpcax] | Preserve r: replication number b: block size u: user g: group p: permission c: checksum-type a: ACL x: XAttr | Modification times are not preserved. Also, when -update is specified, status updates will not be synchronized unless the file sizes also differ (i.e. unless the file is re-created). If -pa is specified, DistCp preserves the permissions also because ACLs are a super-set of permissions. |
| -i | Ignore failures | As explained in the Appendix, this option will keep more accurate statistics about the copy than the default case. It also preserves logs from failed copies, which can be valuable for debugging. Finally, a failing map will not cause the job to fail before all splits are attempted. |
| -log <logdir> | Write logs to <logdir> | DistCp keeps logs of each file it attempts to copy as map output. If a map fails, the log output will not be retained if it is re-executed. |
| -m <num_maps> | Maximum number of simultaneous copies | Specify the number of maps to copy data. Note that more maps may not necessarily improve throughput. |
| -overwrite | Overwrite destination | If a map fails and -i is not specified, all the files in the split, not only those that failed, will be recopied. As discussed in the Usage documentation, it also changes the semantics for generating destination paths, so users should use this carefully. |
| -update | Overwrite if source and destination differ in size, blocksize, or checksum | As noted in the preceding, this is not a “sync” operation. The criteria examined are the source and destination file sizes, blocksizes, and checksums; if they differ, the source file replaces the destination file. As discussed in the Usage documentation, it also changes the semantics for generating destination paths, so users should use this carefully. |
| -f <urilist_uri> | Use list at <urilist_uri> as src list | This is equivalent to listing each source on the command line. The urilist_uri list should be a fully qualified URI. |
| -filelimit <n> | Limit the total number of files to be <= n | Deprecated! Ignored in the new DistCp. |
| -sizelimit <n> | Limit the total size to be <= n bytes | Deprecated! Ignored in the new DistCp. |
| -delete | Delete the files existing in the dst but not in src | The deletion is done by FS Shell. So the trash will be used, if it is enable. |
| -strategy {dynamic|uniformsize} | Choose the copy-strategy to be used in DistCp. | By default, uniformsize is used. (i.e. Maps are balanced on the total size of files copied by each map. Similar to legacy.) If “dynamic” is specified, DynamicInputFormat is used instead. (This is described in the Architecture section, under InputFormats.) |
| -bandwidth | Specify bandwidth per map, in MB/second. | Each map will be restricted to consume only the specified bandwidth. This is not always exact. The map throttles back its bandwidth consumption during a copy, such that the net bandwidth used tends towards the specified value. |
| -atomic {-tmp <tmp_dir>} | Specify atomic commit, with optional tmp directory. | -atomic instructs DistCp to copy the source data to a temporary target location, and then move the temporary target to the final-location atomically. Data will either be available at final target in a complete and consistent form, or not at all. Optionally, -tmp may be used to specify the location of the tmp-target. If not specified, a default is chosen. Note: tmp_dir must be on the final target cluster. |
| -mapredSslConf <ssl_conf_file> | Specify SSL Config file, to be used with HSFTP source | When using the hsftp protocol with a source, the security- related properties may be specified in a config-file and passed to DistCp. <ssl_conf_file> needs to be in the classpath. |
| -async | Run DistCp asynchronously. Quits as soon as the Hadoop Job is launched. | The Hadoop Job-id is logged, for tracking. |
The components of the new DistCp may be classified into the following categories:
The DistCp Driver components are responsible for:
Parsing the arguments passed to the DistCp command on the command-line, via:
Assembling the command arguments into an appropriate DistCpOptions object, and initializing DistCp. These arguments include:
Orchestrating the copy operation by:
The parser-elements are exercised only from the command-line (or if DistCp::run() is invoked). The DistCp class may also be used programmatically, by constructing the DistCpOptions object, and initializing a DistCp object appropriately.
The copy-listing-generator classes are responsible for creating the list of files/directories to be copied from source. They examine the contents of the source-paths (files/directories, including wild-cards), and record all paths that need copy into a SequenceFile, for consumption by the DistCp Hadoop Job. The main classes in this module include:
Based on whether a source-file-list is specified in the DistCpOptions, the source-listing is generated in one of the following ways:
One may customize the method by which the copy-listing is constructed by providing a custom implementation of the CopyListing interface. The behaviour of DistCp differs here from the legacy DistCp, in how paths are considered for copy.
The legacy implementation only lists those paths that must definitely be copied on to target. E.g. if a file already exists at the target (and -overwrite isn’t specified), the file isn’t even considered in the MapReduce Copy Job. Determining this during setup (i.e. before the MapReduce Job) involves file-size and checksum-comparisons that are potentially time-consuming.
The new DistCp postpones such checks until the MapReduce Job, thus reducing setup time. Performance is enhanced further since these checks are parallelized across multiple maps.
The InputFormats and MapReduce components are responsible for the actual copy of files and directories from the source to the destination path. The listing-file created during copy-listing generation is consumed at this point, when the copy is carried out. The classes of interest here include:
UniformSizeInputFormat: This implementation of org.apache.hadoop.mapreduce.InputFormat provides equivalence with Legacy DistCp in balancing load across maps. The aim of the UniformSizeInputFormat is to make each map copy roughly the same number of bytes. Apropos, the listing file is split into groups of paths, such that the sum of file-sizes in each InputSplit is nearly equal to every other map. The splitting isn’t always perfect, but its trivial implementation keeps the setup-time low.
DynamicInputFormat and DynamicRecordReader: The DynamicInputFormat implements org.apache.hadoop.mapreduce.InputFormat, and is new to DistCp. The listing-file is split into several “chunk-files”, the exact number of chunk-files being a multiple of the number of maps requested for in the Hadoop Job. Each map task is “assigned” one of the chunk-files (by renaming the chunk to the task’s id), before the Job is launched. Paths are read from each chunk using the DynamicRecordReader, and processed in the CopyMapper. After all the paths in a chunk are processed, the current chunk is deleted and a new chunk is acquired. The process continues until no more chunks are available. This “dynamic” approach allows faster map-tasks to consume more paths than slower ones, thus speeding up the DistCp job overall.
CopyMapper: This class implements the physical file-copy. The input-paths are checked against the input-options (specified in the Job’s Configuration), to determine whether a file needs copy. A file will be copied only if at least one of the following is true:
CopyCommitter: This class is responsible for the commit-phase of the DistCp job, including:
By default, DistCp makes an attempt to size each map comparably so that each copies roughly the same number of bytes. Note that files are the finest level of granularity, so increasing the number of simultaneous copiers (i.e. maps) may not always increase the number of simultaneous copies nor the overall throughput.
The new DistCp also provides a strategy to “dynamically” size maps, allowing faster data-nodes to copy more bytes than slower nodes. Using -strategy dynamic (explained in the Architecture), rather than to assign a fixed set of source-files to each map-task, files are instead split into several sets. The number of sets exceeds the number of maps, usually by a factor of 2-3. Each map picks up and copies all files listed in a chunk. When a chunk is exhausted, a new chunk is acquired and processed, until no more chunks remain.
By not assigning a source-path to a fixed map, faster map-tasks (i.e. data-nodes) are able to consume more chunks, and thus copy more data, than slower nodes. While this distribution isn’t uniform, it is fair with regard to each mapper’s capacity.
The dynamic-strategy is implemented by the DynamicInputFormat. It provides superior performance under most conditions.
Tuning the number of maps to the size of the source and destination clusters, the size of the copy, and the available bandwidth is recommended for long-running and regularly run jobs.
For copying between two different versions of Hadoop, one will usually use HftpFileSystem. This is a read-only FileSystem, so DistCp must be run on the destination cluster (more specifically, on NodeManagers that can write to the destination cluster). Each source is specified as hftp://<dfs.http.address>/<path> (the default dfs.http.address is <namenode>:50070).
As has been mentioned in the preceding, should a map fail to copy one of its inputs, there will be several side-effects.
To use an HSFTP source (i.e. using the hsftp protocol), a SSL configuration file needs to be specified (via the -mapredSslConf option). This must specify 3 parameters:
The following is an example of the contents of the contents of a SSL Configuration file:
<configuration> <property> <name>ssl.client.truststore.location</name> <value>/work/keystore.jks</value> <description>Truststore to be used by clients like distcp. Must be specified.</description> </property> <property> <name>ssl.client.truststore.password</name> <value>changeme</value> <description>Optional. Default value is "".</description> </property> <property> <name>ssl.client.truststore.type</name> <value>jks</value> <description>Optional. Default value is "jks".</description> </property> </configuration>
The SSL configuration file must be in the class-path of the DistCp program.
Why does -update not create the parent source-directory under a pre-existing target directory? The behaviour of -update and -overwrite is described in detail in the Usage section of this document. In short, if either option is used with a pre-existing destination directory, the contents of each source directory is copied over, rather than the source-directory itself. This behaviour is consistent with the legacy DistCp implementation as well.
How does the new DistCp differ in semantics from the Legacy DistCp?
Why does the new DistCp use more maps than legacy DistCp? Legacy DistCp works by figuring out what files need to be actually copied to target before the copy-job is launched, and then launching as many maps as required for copy. So if a majority of the files need to be skipped (because they already exist, for example), fewer maps will be needed. As a consequence, the time spent in setup (i.e. before the M/R job) is higher. The new DistCp calculates only the contents of the source-paths. It doesn’t try to filter out what files can be skipped. That decision is put off till the M/R job runs. This is much faster (vis-a-vis execution-time), but the number of maps launched will be as specified in the -m option, or 20 (default) if unspecified.
Why does DistCp not run faster when more maps are specified? At present, the smallest unit of work for DistCp is a file. i.e., a file is processed by only one map. Increasing the number of maps to a value exceeding the number of files would yield no performance benefit. The number of maps launched would equal the number of files.
Why does DistCp run out of memory? If the number of individual files/directories being copied from the source path(s) is extremely large (e.g. 1,000,000 paths), DistCp might run out of memory while determining the list of paths for copy. This is not unique to the new DistCp implementation. To get around this, consider changing the -Xmx JVM heap-size parameters, as follows:
bash$ export HADOOP_CLIENT_OPTS="-Xms64m -Xmx1024m" bash$ hadoop distcp /source /target


Invalid username and/or password
Please check if you specified a username and password then try again.


Use this overload when you're not interested in the parameters.
Parameters
Action
callback
Specifies the function which is called when the method under configuration is called.
Type ICommandOptions
Namespace Machine.Fakes
Use this overload when you're not interested in the parameters.
Action
callbackSpecifies the function which is called when the method under configuration is called.
Use this for callbacks on methods with a single parameter.
Action<T>
callbackSpecifies the function which is called when the method under configuration is called.
Use this for callbacks on methods with two parameters.
Action<T1, T2>
callbackSpecifies the function which is called when the method under configuration is called.
Use this for callbacks on methods with three parameters.
Action<T1, T2, T3>
callbackSpecifies the function which is called when the method under configuration is called.
Use this for callbacks on methods with four parameters.
Action<T1, T2, T3, T4>
callbackSpecifies the function which is called when the method under configuration is called.
Exception
exceptionSpecifies the exception which should be thrown when the behavior is invoked.


Welcome to my homepage! Here you will find a little bit about me. I like technology, both old and new. I like to stay up to date with the latest tech and read about new products that come out.
I have been attending Mount Hood Community College pursuing my AAS in Computer Information Systems. I currently work as a sales associate at Fred Meyer to establish a work history. I joined Epicodus so I could learn programming exclusively and in a focused environment. The ideas behind pair programming is great, as it helps me learn faster with a partner. I hope to learn more as time goes on, and possibly attend the full time class if I do well in the intro class.


Home
Lessons
Exercies
## Exercice List Below is an order list of all the exercices we will be doing ### Agenda 1. [Create CSS](/exercices/exercices-1.html) 2. [Create Some JSX](/exercices/exercices-2.html) 3. [Import Component](/exercices/exercices-3.html) 4. [Import some JSON](/exercices/exercices-4.html) 5. [Props](/exercices/exercices-5.html) 6. [Classes](/exercices/exercices-6.html) 7. [Changing the state](/exercices/exercices-7.html) 8. Making an API call ---


Queue
Thu, Oct 22, 2015author: Stefan Majoor
In our organization we frequently need to execute some scripts that are either time consuming, or very heavy on the server. Most of the times these scripts needn’t necessarily be executed synchronously. Therefore we use a queuing system to execute those scripts when the time is better. For a long time we used an old open source PHP queuing system, named fuel-queue. This was good for the basic stuff we did with it, however this system had some major drawbacks. It had no exception management whatsoever, which meant that jobs now and then just disappeared. Lately we have encountered more and more projects that would need queuing. We made the decision to create a new queuing system. We really liked the idea behind fuel-queue, and have made our new system in such a way that it kept this idea. The best thing is that we made this new queuing system is completely open source!
Presenting Queue
Today we finally present our latest project. Queue is a queuing system made for the FuelPHP framework. This plugin is written from the ground up, taking what we liked in the old fuel-queue project in mind. The main focus during development was stability. This means that great care is taken in error handling, ensuring that no data is lost. Furthermore, a lot of unittests are written. Great care is taken in writing the software. The code is well documented, and can easily be adapted to your needs. This all results in a highly reliable software package which can easily be used in your own projects. The best news is that the project is released under MIT licence, so you can use the source code without restrictions.
###Features * A wide variety of features is available in this version of the queueing system. A small selection of the features: * Simple usage, easy to integrate in your project. Great care is taken to make good documentation, and to create a software package which can easily be adapted to your personal needs. * Different queues can run in parallel. You can turn queues on and off whenever you want, meaning that you yourself can decide when you want to run which functions. This makes it possible for example to run tasks that are very heavy on the system on quieter times, preventing hinder to the end user of your product. * Executes any static function, with arguments. * Set priorities for the job. High priority jobs are executed earlier. * Delayed execution. Do you need to send an email tomorrow? You can just add it to the queue now. The queue will take care that it will be send whenever you want it to be send. * Detailed error messages. Of course jobs may fail because of a wide variety of reasons. Luckily the application will log the error messages, making it easier for you to find errors in your code. * Status panel showing all the jobs. A status panel for the queuing system is available, and can easily be integrated in your projects. This panel will show you the status of the different jobs in the project.
###Why use a queuing system? Although you may not realize it, your software may benefit greatly from usage of queuing system. From our perspective there are three reasons why a queuing system may come in handy:
- Resolve long execution times. Now and then a user performs an action that needn’t necessarily be executed at that moment. Slow page responses have a major impact on consumers. Therefore, using a queue can help to improve consumer satisfactions.
- There are certain types of actions that do require a lot of power from the server. Think for example when a report needs to be made from a lot of data. This means that you need to have an extremely well performing server, or you will experience some performance issues. With a queuing system you can delay this actions until times that are less busy, such that users won’t notice it.
- A good usage for a queuing system is for delayed execution of processing. For example, do you need to send a mail in 24 hours? You can add it now to the queue, and you can be sure that it will be executed in 24 hours.
###Want to contribute? If you have an awesome idea for the queuing system you are of course welcome to help. For development we are using BitBucket. This enables you to open new tickets. Just open a tickets if you find a bug, think of a good feature, and just have got an awesome idea in general.


| Metamath Music Page | ||
| Mirrors > Home > Metamath Music Page |
| Contents of this page |
The Metamath Music Page offers some eerie
sounds that will certainly pass for music in avant-garde circles. We
must admit to a certain fascination at hearing the steps of a proof
rendered as notes that occasionally announce themes, only to abandon
them.
— AK Dewdney (author, The Turing Omnibus)
Metamath Music Page - Proofs you can listen to in MIDI format. Fun
and edjemacational!
...instead of turning in analysis homework, I'll just bring an electronic
piano to class and play the proof for my professor.
|
Is it "music"? I guess that's for you to decide. It is richly structured, with underlying themes that on the one hand seem to repeat but on the other hand are interestingly unpredictable, teasing your mind as the piece progresses.
For these MIDI files, make sure your media player is set to a "piano" sound and not an "electronic organ" sound, otherwise it will sound horrible, because the sustained notes need to decay automatically. For example, I had to select Yamaha OPL3-SA SoftSynth from Devices/Properties in Microsoft Media Player on a Windows 95 computer I tried. More recent computers seem to default to the piano sound. If you are using QuickTime, it has a bug that sometimes causes a burst of loud, annoying static at the beginning of a piece; you can work around this bug by changing the MIDI settings [retrieved 3-Feb-2017 from archive.org].
I set the tempo quite fast, partly to help you decide more quickly whether it interests you. (The tempo can be slowed down by rerunning the program that generated these.) I chose to give the selections a "syncopated" character by substituting a repeated note with a silent pause, since to me it usually sounded a little better. The frenetic non-syncopated version can be interesting too, with one note for every proof step. Sometimes, syncopation has only a small effect, as in the case of the Second Peano Postulate 0:16. Other times the effect is significant; compare the syncopated1:49 and non-syncopated1:49 versions of the Triangle Inequality (and also another version). Another curious piece with a pronounced syncopated effect is the Square Root Theorem 0:41.
In deeper proofs, a kind of tension sometimes builds up, with occasional partial relief but growing overall, until finally many subproofs come together. For example, you may want to sample the Axiom of Choice Equivalent 3:51, where a crescendo slowly builds up starting at around 2:20 minutes, reaching a dramatic climax at 3:11 minutes and then suddenly cascading down to the main theme. Another frenzied, climactic piece is Zermelo's Well-Ordering Theorem 0:50. The Schröder-Bernstein Theorem 1:47 (I like this one) changes its theme during its course, starting off with a ominous staccato then breaking out into a colorful display of notes.
The music generated from these mathematical proofs stands in sharp contrast to certain other experimental music based on such mathematics as the digits of π (pi). Unlike a proof's tree structure, which is inherently suggestive of a musical score, the digits of π have no obvious pattern. To make it interesting, a human composer will often add a non-mathematical creative element such as an underlying beat with pre-selected chords and instrumentation. What one hears, then, might be based as much on the originality of the composer as on the essential nature of π: the same algorithm applied to the digits of say e (Euler's constant), or even a series of random digits, would typically sound about the same after the first few notes. The music here, on the other hand, is a raw and unadorned representation of the mathematics itself, involving few human preconceptions beyond a basic mapping needed to accommodate the Western tonal scale.
The theorems below are from (the August 2000 version of) the Theorem Sampler on the Metamath Proof Explorer Home Page. Click on a theorem name to see its proof, and click on the musical note to hear it set to music. The music is faithful to the original proofs. For example, the five sustained (lower) notes you will hear in the Law of Identity match, in order, the five steps of its proof, while the faster notes represent the construction of the formulas used in those steps.
Each of the above proofs is actually just the highest level of each theorem's proof, where typically several other theorems are pieced together to obtain the final result. In fact the Metamath database has over 7,000 other proofs - who knows what they sound like!
What does this mean? I'm not sure, other than that it says something about the complexity of the music structure. But it looks neat. [Images used by permission of Martin Wattenberg.]
Here is how to generate these melodies with the Metamath program. There are currently over 19,000 proofs in the Metamath database set.mm, each with a different melody.
For Windows:
Step 1. Extract the file t2mf.exe (a program
that converts a text file to a MIDI file) from mf2t.zip, which
you can download from
http://www.hitsquad.com/smm/programs/mf2t/download.shtml [retrieved
3-Feb-2017]. (You can also download and unzip mf2t.zip. The t2mf.exe file is located
in the folder mf2t\mf2t-original\mf2t\.)
Step 2. Extract the files metamath.exe (the Metamath program) and set.mm (the Metamath set theory database) from metamath.zip, which is the Metamath Program download.
Step 3. Put the three files metamath.exe, set.mm and t2mf.exe into a new directory (folder).
Step 4. Browse through the Metamath Proof Explorer proof pages to find a proof you want to listen to. For this example, we'll suppose you want to listen to the Schröder-Bernstein Theorem, whose proof page is sbth.html. The name "sbth" is the name of the theorem that you will give to the program.
Step 5. Let's say you called your new directory C:\metamidi in Step 3. To create the MIDI file for theorem sbth, open an MS-DOS or Command Prompt window (Start -> Programs -> Accessories -> Command Prompt, or Start -> Run -> command, or Start -> Run -> cmd) and type:
C:\WINDOWS>cd \metamidi C:\metamidi>metamath set.mm MM> midi sbth /parameter "fsh" Creating MIDI source file "sbth.txt"... length = 107 sec MM> exit C:\metamidi>t2mf sbth.txt sbth.midNow you can play the MIDI for the Schröder-Bernstein Theorem 1:47 by clicking on sbth.mid in the Windows Explorer.
The parameter argument is specified by a combination of the following letters, with no spaces separating them:
You can see what theorems are available by typing "show labels". In general you can use "help" to guide you, including "help midi".
Tip:The "midi" command in Metamath will not destroy existing files, but will rename an existing one with ~1 appended (for example, an older sbth.txt would be renamed sbth.txt~1), an existing ~1 to ~2, etc. up to ~9. (An existing ~9 is deleted.) This makes it safer to use but also will clutter up your directory, so you may want to clean them out occasionally.
Tip: There is a problem with t2mf.exe: it can only handle Microsoft's 8.3 file format (8-character file name, period, and 3-character extension). It will complain if you ask it to convert pm2.11.txt because a file name can't have 2 periods, so you have to use the "real" Microsoft file name such as PM211~1.TXT which you can see with the MS-DOS DIR command (or DIR/X in the Windows XP Command Prompt). Alternately you could rename the file to, say, pm2_11.txt before running t2mf.exe. I am not the author of t2mf.exe and unfortunately have no other solution at this point.
MacOSX:
In 2006, Luca Ciciriello
modified the program to run on MacOSX. Download and unzip mf2t.zip. The files are located
in mf2t/mf2t-Mac/. I have not tested it personally.
For Unix/Linux:
The t2mf program was written in 1991, before C was standardized by ANSI,
and it will not compile on modern compilers. However, if you wish to
attempt to convert it to modern C, download and unzip mf2t.zip. The source files are located
in mf2t/mf2t-original/mf2tsrc/, which includes the sources for t2mf. You
may also wish to consult the sources for Luca Ciciriello's Mac upgrade,
located in
mf2t/mf2t-Mac/Midi_MacOSX_Xcode/Midi_MacOSX_Xcode/midisrc/t2mf/. If you
are successful, let me know and I will add it to the mf2t.zip download.
Note that the authors Tim Thompson (original author) and M. Czeiszperger
agreed to place their code in the public domain, but I was unable to
contact Piet van Oostrum who made some additional modifications to the
code.
For Unix/Linux and MacOSX:
Assuming you have successfully compiled t2mf,
next download the file
metamath.tar.gz.
Type:
$ tar -xzf metamath.tar.gz
This will create a directory called "metamath". To compile the program with gcc, type
$ cd metamath $ gcc m*.c -o metamathNow you can run the Metamath program, then t2mf, to create the MIDI file:
$ ./metamath MM> read "set.mm" MM> midi sbth /parameter "fsh" Creating MIDI source file "sbth.txt"... length = 107 sec MM> exit $ t2mf sbth.txt sbth.mid
See the notes above for Windows for information on the parameters.
MM> save proof idALT / normalThen we type
MM> show proof idALT / allThis will show the microsteps that construct wffs, as well as regular proof steps, in the form of an indented proof tree. The notation for proofs is described in the Metamath book (1.3Mb) if you are interested. You'll see:
1 wph=wph $f wff ph 2 wph=wph $f wff ph 3 wps=wph $f wff ph 4 wps=wi $a wff ( ph -> ph ) 5 wph=wi $a wff ( ph -> ( ph -> ph ) ) 6 wph=wph $f wff ph 7 wps=wph $f wff ph 8 wps=wi $a wff ( ph -> ph ) 9 wph=wph $f wff ph 10 wps=wph $f wff ph 11 min=ax-1 $a |- ( ph -> ( ph -> ph ) ) 12 wph=wph $f wff ph 13 wph=wph $f wff ph 14 wps=wph $f wff ph 15 wph=wi $a wff ( ph -> ph ) 16 wps=wph $f wff ph 17 wps=wi $a wff ( ( ph -> ph ) -> ph ) 18 wph=wi $a wff ( ph -> ( ( ph -> ph ) -> ph ) ) 19 wph=wph $f wff ph 20 wph=wph $f wff ph 21 wps=wph $f wff ph ...

We want to fit the proof within a desirable maximum dynamic range of note frequencies, which I defined as 27 < n < 104, where n is the midi note number. We obtain an the largest possible integer "scale factor", with a maximum of 4, that allows the music to fit in the dynamic range. For the idALT proof, the scale factor will be 4.
We also compute a "baseline" note which allows the proof to fit in the dynamic range. For the idALT proof, the baseline is 61.
We multiply the indentation level by the scale factor 4 and add it to the baseline. In addition, whenever we encounter a "logical" (real) proof step (as opposed to a formula-building proof step), identified by a |- in the proof listing, we shift the note down by 12 (one octave) and sustain it rather than turning it on and off.
So in this example the midi note numbers will be
be
69,73,73,69,65,69,73,65,69,69,53,73...
where 53 = 65-12 is the shifted note of step 11, which you can see
has a |- in it in the proof listing.
Finally, if syncopation is selected, which was the case for all the
selections on this page, repeated notes are replaced with silence. (The
sustained notes are not syncopated.) So what we hear through step 12
above is
69,73,-,69,65,69,-,65,69,-,53,73,...
where the 53 is the first sustained note.
Now, listen carefully to the Law of Identity 0:05, and you will hear that the first 12 notes and pauses match exactly the above sequence.
"Kind of amusing in that the entire output of these pages proves a theorem of its own: that not all mathematicians make good music (take THAT, Douglas Hofstadter!). Mis-step one was to program using only equal distances between pitches (MIDI note numbers), resulting in endless whole-tone melodies." —musician Tom Djll [external](By the way, the "b", "w", and "i" parameters that are already available may appeal to more conventional musical tastes. An example is the Triangle Inequality 1:49 played with the black keys, using the parameter string "fsbi". To me it lacks some of the vaguely disturbing eeriness of the other versions, and there is a certain gentle pleasantness to it. What do you think?)
To modify the algorithm, download the Metamath program, which includes the source code. In the file mmcmds.c, at the very end you will find the function outputMidi() which generates the MIDI file. I put in a lot of comments, so hopefully you won't find it too hard to follow what it does. I recommend confining any experiments to this function, which gives you access to everything you should need. Let me know if there is something you don't understand.
Tip: In Metamath program download, the C programs are stored in Unix ASCII format with no carriage-return at the end of lines. If you are using Windows, see the note on text files at the end of the download help section.
The user parameter from the "/parameter" argument in the Metamath "midi" command is just an arbitrary string that is not syntax-checked, and you can use it to put in your own parameters to experiment with.
To compile the program, you need an ANSI C compiler such as gcc, which is built into Linux and available free for Windows as part of Cygwin [external]. Assuming you have only the Metamath source files in your directory, you type in the Cygwin or Linux shell
gcc m*.c -o metamath.exewhere you omit the .exe in Unix/Linux.
"Natural music has fascinated me for some time.... It is a strange music that seems to speak to the soul in a way that manufactured music cannot."
The "Abstricombo" arrangement is copyright © 2000 by DarkBlues.
The "78 RPM record label" image may be copyright and/or trademarked by says-it.com. The "Shape of Song" images are copyright by Martin Wattenberg. Any short attributed quotations may be copyright by their authors. All other text and images on this page are placed in the public domain.
See also Metamath Web Site - Copyright Terms.
| This
page was last updated on 3-Feb-2017. Your comments are welcome: Norman Megill metamath.org mirrors |
W3C HTML validation [external] |


Cargos expected to depart from POL
Cargos expected to arrival at POD
Cargos waiting for transshipment before arrival of a second carrier
Click the number you want to edit.
1
3days
Fri. Apr 02 2021
08:20 am
Le Havre, France
TGBU8030389 2021-07-18 (FDEST ETA) Source: Manual
12:50 am
2021-06-22 (TS) Port Congestion Source: Irregularity Irre No: EXCT202107220009
Sat. Apr 03 2021
02:10 am
Hong Kong
2021-06-30 17:10 Typhoon, Storm Projected path for Tropical Cyclo .. Source: GDACS read more


Cisco IOS-XE 3.7, rancid-git 2.3.9 on Ubuntu 14.4, git 1.9.1
I use rancid to back up configs of network devices, but giving an automated process like rancid full access to switches, routers, and firewalls is a horrible idea. If someone breaks into the Linux rancid account (or wherever the rancid program runs), they pretty much own your network because the rancid scripts either have the password or ssh private key for logging into network devices.
You don't have to give rancid full access to IOS though. You can configure a privilege level to provide just what rancid needs to backup the configs and nothing more. There is still a security risk because rancid can see password hashes, so you should make sure your users use strong passwords. You can just generate random strong passwords for users rather than letting them choose passwords.
Configure privilege level 2 to allow only the commands rancid needs:
privilege exec level 2 dir /all bootflash: privilege exec level 2 dir /all disk0: privilege exec level 2 dir /all disk1: privilege exec level 2 dir /all disk2: privilege exec level 2 dir /all harddisk: privilege exec level 2 dir /all harddiska: privilege exec level 2 dir /all harddiskb: privilege exec level 2 dir /all nvram: privilege exec level 2 dir /all sec-bootflash: privilege exec level 2 dir /all sec-disk0: privilege exec level 2 dir /all sec-disk1: privilege exec level 2 dir /all sec-disk2: privilege exec level 2 dir /all sec-nvram: privilege exec level 2 dir /all sec-slot0: privilege exec level 2 dir /all sec-slot1: privilege exec level 2 dir /all sec-slot2: privilege exec level 2 dir /all slavebootflash: privilege exec level 2 dir /all slavedisk0: privilege exec level 2 dir /all slavedisk1: privilege exec level 2 dir /all slavedisk2: privilege exec level 2 dir /all slavenvram: privilege exec level 2 dir /all slavenslot0: privilege exec level 2 dir /all slavenslot1: privilege exec level 2 dir /all slavenslot2: privilege exec level 2 dir /all slavesup-bootflash: privilege exec level 2 dir /all slavesup-slot0: privilege exec level 2 dir /all slavesup-slot1: privilege exec level 2 dir /all slavesup-slot2: privilege exec level 2 dir /all sup-bootdisk: privilege exec level 2 dir /all sup-bootflash: privilege exec level 2 dir /all sup-microcode: privilege exec level 2 more system:running-config privilege exec level 2 show boot privilege exec level 2 show bootvar privilege exec level 2 show c7200 privilege exec level 2 show capture privilege exec level 2 show controllers privilege exec level 2 show controllers cbus privilege exec level 2 show crypto pki certificates privilege exec level 2 show debug privilege exec level 2 show diag privilege exec level 2 show diag chassis-info privilege exec level 2 show diagbus privilege exec level 2 show env all privilege exec level 2 show flash privilege exec level 2 show gsr chassis privilege exec level 2 show idprom backplane privilege exec level 2 show install active privilege exec level 2 show interface privilege exec level 2 show inventory raw privilege exec level 2 show ip interface privilege exec level 2 show ipv6 interface privilege exec level 2 show module privilege exec level 2 show redundancy secondary privilege exec level 2 show rsp chassis-info privilege exec level 2 show running-config privilege exec level 2 show running-config view full privilege exec level 2 show shun privilege exec level 2 show snmp engineID privilege exec level 2 show snmp mib ifmib ifindex privilege exec level 2 show spe version privilege exec level 2 show standby privilege exec level 2 show variables boot privilege exec level 2 show variables boot privilege exec level 2 show version privilege exec level 2 show vlan privilege exec level 2 show vlan-switch privilege exec level 2 show vtp status privilege exec level 2 write term
Now create the rancid user, generate a random password for the account, and only allow the the account to sign in from <IP_ADDRESS>
access-list 95 permit <IP_ADDRESS> username rancid privilege 2 access-class 95 secret 2NANyrnyxRJie1WtGjtTxcXnesLu ip ssh pubkey-chain username rancid key-string ssh-rsa AAAAB3[...]vv6X rancid exit exit
In my testing, this was enough for the rancid program (I use the git fork at https://github.com/dotwaffle/rancid-git) to download the configuration from IOS devices and push them to the git repo.


This is a tool to show the history of your bike on hellocycling.jp. See which port he has been riding your bike on.
Book


Hello friends! We started learning Ruby this week, very basic stuff but you have to start somewhere so why not start at the beginning? Today we'll be talking about arrays and hashes, two systems Ruby uses to store collections of objects. Let's begin!
Arrays and hashes are very similar, but are used in different ways. As with everything in Ruby, an array and a hash are both objects. Both are used to store collections of objects, be that integers, strings, or even other arrays and hashes! The main difference between them is that arrays are ordered collections and hashes are unordered. When you assign a value in an array, that is, give it something to hold on to, you define where in the array the value should go. This is called an index, and it looks like this: array[3]. Because arrays start counting at 0 instead of 1, array[3] is the fourth item in the array. There are many methods that move items in the array around, but we always reference items in the array by referring to their index.
A hash, on the other hand, can store any value like an array can, but instead of giving the value an index we give it a key. A key is like an index, but does not have any inherent order in the hash. For example, if I wanted to store the value 'Obama' in a hash I might give it the key 'President'. Thus, I would be able to retrieve that value from the hash by calling hash['President']. It can be helpful to think of a hash like a dictionary, with the key being a word or symbol that points to a definition, the value. Key => value. In fact, this is exactly how we assign keys and values to a hash, with the command hash = {key => value}. Cool, huh?


Passengers on board Australia's biggest cruise liner caught up in New Zealand's volcano tragedy describe the horror of watching the injured be brought back to the ship
by Zoe Zaczek For Daily Mail Australia- Whakaari, also known as White Island, erupted about 2pm local time on Monday
- Five people died, 18 were rescued and at least 27 tourists are unaccounted for
- Tourists who were aboard Ovation of the Seas are believed to be among missing
- The cruise ship, which originated in Sydney, has docked in Tauranga overnight
- Passengers have said they were 'grateful' they didn't go on a tour of Whakaari
Tourists on Australia's biggest cruise ship are 'grateful' they decided to stay on board after passengers and crew members were caught up in New Zealand's volcano tragedy.
At least five people died in the powerful eruption on White Island, also known as Whakaari, at 2.11pm local time on Monday when an estimated 50 tourists were on or around the volcano crater.
Eighteen survivors were evacuated - some suffering severe burns - leaving an estimated 27 people unaccounted for.
Australians were among the visitors on Whakaari from a nearby cruise ship, the Ovation of the Seas, which originated in Sydney.
The vessel, which has 4579 passengers and 1595 crew on board, is docked in Tauranga, 90 kilometres from White Island.
Kasey Bebrouth, who lives in Ipswich, Queensland, wrote on Facebook she was safe on the cruise ship after choosing not to tour the island.
'Okay so me and Marty are on the Ovation of the Seas and yes people have been hurt,' she wrote.
'The boat is staying overnight. At this point we are OK but very grateful that we stayed on the ship.
'We thank everyone for their kind words and worries. We will post more when we know more, just know that we are safe.'
Her friend Stephen Irvine told News Corp he had been messaging the mother-of-one after the eruption and she said she saw injured passengers covered in ash being carried back to the boat.
'The passengers have been offered counselling,' Mr Irvine said.
Stephanie Wright, whose Facebook says she's a lighting technician at Royal Caribbean International, also wrote a status about being safely docked at Tauranga.
'This is absolutely tragic. I'm on Ovation of the Seas,' Ms Wright wrote.
'We're docked overnight in Tauranga hoping and waiting for news and the return of our crew and passengers.
'Keep them in your thoughts and if you pray, hold them there too.'
The captain of the vessel announced one crew member and a group of passengers were on the island when the volcano erupted, New Zealand Herald reported.
Passenger Nigel Walker, from Wollongong, south of Sydney, extended his thoughts to those missing.
'It's tragic... I was only saying to my mother-in-law before the cruise that White Island would be a great place to visit,' he said.
Royal Caribbean issued a statement saying the ship would stay in the nearby port overnight 'until we learn more about the situation'.
The vessel, which embarked on a 12-day cruise from Sydney, was supposed to sail to Wellington on Monday evening before touring New Zealand’s South Island and returning to Circular Quay.
Michael Schade, a traveller from San Francisco, said his tour group was standing at the edge of the main crater less than 30 minutes before the blast.
'My god, White Island volcano in New Zealand erupted today for first time since 2001,' he wrote on Twitter.
'My family and I had gotten off it 20 minutes before, were waiting at our boat about to leave when we saw it.
'Boat ride home tending to people our boat rescued was indescribable.'
Mr Schade shared video footage of the destruction and some of the tourists who managed to escape onto his vessel.
'Praying for them and their recovery. Woman my mum tended to was in critical condition but seemed strong by the end.
'My thoughts with the families of those currently unaccounted for, the people recovering now, and especially the rescue workers.'
Brazilian tourist Allessandro Kauffmann, who was on a tour to the island, shared a series of Instagram stories throughout the day and said he fled moments before the eruption.
'Some people have extensive burns on their bodies. Two tours on the volcano. Ours was the first. The other one right after,' he said after escaping.
'We left the island and wasn't even five minutes before it erupted. This other tour that arrived after couldn't leave in time.
'We had to stay to help those people who were on the island. The boat from this other tour was covered in ash from the volcano.
'Very tense talking about this. We just have to hope that all is as well as can be.'
His partner Aline Moura shared videos of the eruption to Instagram to recount her day.
'This was the end of today's trip that I had. The beginning was excellent, lots of cool pictures, amazing experience,' she wrote.
'But nature is autonomous and man has no control over his will.
'Surely we never forget that day. Let us pray that everyone will be fine.'
Speaking in a series of Instagram stories, the couple recalled how their boat helped rescue people who suffered burns from the eruption.
Police and emergency services haven't been able to reach or make contact with those trapped by the blast.
National Operation Commander Deputy Commissioner John Tims told reporters on Monday evening that it's currently too dangerous to search for survivors.
'There are possibilities of further eruptions. The physical environment is unsafe for us to return to the island,' he said.
'It is important that we consider the health and safety of those that are going to rescue those on the island. So we will be taking that advice.'


BootStrap Component Design
Click here to see the modal
Modal Heading
This is a custom modal designed
Save
Close


| Mission Ids |
1">
{{launchData.missionIds}}
|
|---|---|
| Launch Year | {{launchData.launchYear}} |
| Successful Launch | {{launchData.launchSuccess}} |
| Successful Landing | {{launchData.landSuccess}} |


This is a parser, processor and visualiser for CGA Shape Grammars. It currently only implements a very small subset, and is certainly very buggy. It is only really tested in Chrome.
Rotate the 3d view with left-mouse button, pan with the right, zoom with the scroll wheel. Type in the box, see changes in the 3d view. Chose the things from the drop-down menus.
You grammar will be saved in localStorage, so you can come back later!
Go look at the complete CGA reference.
Grab the source from GitHub.
split
)comp
)color("red")
)extrude
and taper
s, t, r
[ .. ]
rand
functionscope.width/2
/ comparisons scope.height>3
roof*
envelope, offset, setback, ...
Have fun! If you make anything cool I'd love for you to tell me on twitter: @gromgull


Dataset for statmodels: design proposal¶
One of the thing numpy/scipy is missing now is a set of datasets, available for demo, courses, etc. For example, R has a set of dataset available at the core.
The expected usage of the datasets are the following:
- examples, tutorials for model usage
- testing of model usage vs. other statistical packages
That is, a dataset is not only data, but also some meta-data. The goal of this proposal is to propose common practices for organizing the data, in a way which is both straightforward, and does not prevent specific usage of the data.
Background¶
This proposal was adapted from David Cournapeau’s original proposal for a datasets package for scipy and the learn scikit. It has been adapted for use in the statsmodels scikit. The structure of the datasets itself, while specific to statsmodels, should be general enough such that it might be used for other types of data (e.g., in the learn scikit or scipy itself).
Organization¶
Each dataset is a directory in the datasets directory and defines a python package (e.g. has the __init__.py file). Each package is expected to define the function load, returning the corresponding data. For example, to access datasets data1, you should be able to do:
>>> from statsmodels.datasets.data1 import load
>>> d = load() # -> d is a Dataset object, see below
The load function is expected to return the Dataset object, which has certain common attributes that make it readily usable in tests and examples. Load can do whatever it wants: fetching data from a file (python script, csv file, etc…), from the internet, etc. However, it is strongly recommended that each dataset directory contain a csv file with the dataset and its variables in the same form as returned by load so that the dataset can easily be loaded into other statistical packages. In addition, an optional (though recommended) sub-directory src should contain the dataset in its original form if it was “cleaned” (ie., variable transformations) in order to put it into the format needed for statsmodels. Some special variables must be defined for each package, containing a Python string:
- COPYRIGHT: copyright informations
- SOURCE: where the data are coming from
- DESCHOSRT: short description
- DESCLONG: long description
- NOTE: some notes on the datasets.
See datasets/data_template.py for more information.
Format of the data¶
This is strongly suggested a practice for the Dataset object returned by the load function. Instead of using classes to provide meta-data, the Bunch pattern is used.
class Bunch(dict):
def __init__(self,**kw):
dict.__init__(self,kw)
self.__dict__ = self
See this Reference
In practice, you can use
>>> from statsmodels.datasets import Dataset
as the default collector as in datasets/data_template.py.
The advantage of the Bunch pattern is that it preserves look-up by attribute. The key goals are:
- For people who just want the data, there is no extra burden
- For people who need more, they can easily extract what they need from the returned values. Higher level abstractions can be built easily from this model.
- All possible datasets should fit into this model.
For the datasets to be useful in statsmodels the Dataset object returned by load has the following conventions and attributes:
- Calling the object itself returns the plain ndarray of the full dataset.
- data: A recarray containing the actual data. It is assumed that all of the data can safely be cast to a float at this point.
- raw_data: This is the plain ndarray version of ‘data’.
- names: this returns data.dtype.names so that name[i] is the i-th column in ‘raw_data’.
- endog: this value is provided for convenience in tests and examples
- exog: this value is provided for convenience in tests and examples
- endog_name: the name of the endog attribute
- exog_name: the names of the exog attribute
This contains enough information to get all useful information through introspection and simple functions. Further, attributes are easily added that may be useful for other packages.
Adding a dataset¶
See the notes on adding a dataset.
Example Usage¶
>>> from statsmodels import datasets
>>> data = datasets.longley.load()
Remaining problems:¶
- If the dataset is big and cannot fit into memory, what kind of API do we want to avoid loading all the data in memory ? Can we use memory mapped arrays ?
- Missing data: I thought about subclassing both record arrays and masked arrays classes, but I don’t know if this is feasable, or even makes sense. I have the feeling that some Data mining software use Nan (for example, weka seems to use float internally), but this prevents them from representing integer data.
- What to do with non-float data, i.e., strings or categorical variables?
Current implementation¶
An implementation following the above design is available in statsmodels.
Note¶
Although the datasets package emerged from the learn package, we try to keep it independant from everything else, that is once we agree on the remaining problems and where the package should go, it can easily be put elsewhere without too much trouble. If there is interest in re-using the datasets package, please contact the developers on the mailing list.


STP_ADMIN_P2P STP_GetPortAdminPointToPointMAC ( const STP_BRIDGE* bridge, unsigned int portIndex, );
Gets the adminPointToPointMAC
variable for a given port.
See §11.3 in 802.1AC-2016 for more information.
This function may be called from within an STP callback.


Tip: Use your Mobile
Please check this page on your mobile device in order for the sharing links to actually share the page you're on! These do not work in the demo iframe we have on ThemeForest.
Share via Sheet or Modal
You can also share via action sheets. These are non-intrusive and provide a gorgeous user experience
Open Sheet Open ModalSocial Pills & Buttons
Add social icons after any content block or element, after tapping it, the page will automatically generate the share link.
Share to FacebookShare to Twitter
Share to Pinterest
Share to Linkedin
Share via WhatsApp
Share via Email
Text Links
Any link can have the option to automatically pick up the page link and share on click.
Share To FacebookShare To Twitter
Share To LinkedIn
Share To Pinterest
Share To WhatsApp
Share To Mail


Analyzing longitudinal data -- a simple pre-post design
A skeletal response to a twitter question:
“ANOVA (time point x group) or ANCOVA (group with time point as a covariate) for intervention designs? Discuss.”
follow-up “Only 2 time points in this case (pre- and post-intervention), and would wanna basically answer the question of whether out of the 3 intervention groups, some improve on measure X more than others after the intervention”
Here I compare five methods using fake pre-post data, including
- lm-cov. A linear model with baseline as a covariate. This is “ANCOVA” in the ANOVA-world.
- clda. constrained longitudinal data analysis (cLDA). A linear mixed model in which the intercept is constrained to be equal (no treatment effect at time 0).
- rmanova. Repeated measures ANOVA.
- lmm. A linear mixed model version of rmanova. A difference is the rmanova will use a sphericity correction.
- two-way. Linear model with Treatment and Time and their interaction as fixed factors. Equivalent to a Two-way fixed effects ANOVA in ANOVA-world.
I use a simulation to compute Type I error rate and Power. This is far from a comprehensive simulation. Like I said, its skeletal.
TL;DR. At the risk of concluding anything from a very skeletal simulation:
- lm-cov has best performance in since of combining control of Type I error and relative power
- smaller SE in clda comes at a cost of relatively high Type I error but increased powers. Do with this what you will.
- rmanova has smaller power than lm-cov
Not included: I didn’t save the results necessary to plot type I error conditional on baseline difference, which is well controlled by lm-cov (and clda) but not by lmm or rmanova.
libraries
library(data.table)
library(nlme)
library(emmeans)
library(afex)
library(ggpubr)
library(ggsci)
library(cowplot)
simulation functions
pre-post fake data generator
My general algorithm for creating pre-post data with a single post time point differs from how I create pre-post data with multiplee post time points.
generate_pre_post <- function(
n = 6, # if vector then sample per group
sigma_0 = 1, # error at time 0
sigma_1 = 1, # error at time 1
rho = 0.6, # correlation between time 0 and 1
beta_0 = 10, # control mean at time 0
beta_1 = 1, # treatment effect at time 1
beta_2 = 5 # time effect at time 1
){
if(length(n) == 1){n <- rep(n,2)} # set n = n for all groups
N <- sum(n)
fd <- data.table(
treatment = factor(rep(c("cn", "tr"), n))
)
X <- model.matrix(~treatment, data=fd)
z <- rnorm(N) # z is the common factor giving correlation at time 0 and 1. This
# is easier for me than making glucose_1 = glucose_0 + treatment + noise
fd[, glucose_0 := beta_0 + sqrt(rho)*z + sqrt(1 - rho)*rnorm(N, sd=sigma_0)]
fd[, glucose_1 := beta_0 + sqrt(rho)*z*sigma_1 + sqrt(1 - rho)*rnorm(N, sd=sigma_1) +
X[,2]*beta_1 + # add treatment effect
beta_2 # add time effect
]
fd[, change := glucose_1 - glucose_0] # change score
fd[, id := factor(1:.N)]
return(fd)
}
test FDG
fd <- generate_pre_post(
n = c(10^5, 10^5),
sigma_0 = 1,
sigma_1 = 2,
rho = 0.6,
beta_0 = 10,
beta_1 = 1
)
m1 <- lm(glucose_1 ~ treatment, data = fd)
fd[, glucose_1_cond := coef(m1)[1] + residuals(m1)]
coef(summary(m1))
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 15.0086453 0.006318270 2375.4359 0
## treatmenttr 0.9873514 0.008935383 110.4991 0
cov(fd[, .SD, .SDcols=c("glucose_0", "glucose_1_cond")])
## glucose_0 glucose_1_cond
## glucose_0 1.00213 1.197850
## glucose_1_cond 1.19785 3.992034
cor(fd[, .SD, .SDcols=c("glucose_0", "glucose_1_cond")])
## glucose_0 glucose_1_cond
## glucose_0 1.000000 0.598885
## glucose_1_cond 0.598885 1.000000
coef(summary(lm(glucose_1 ~ glucose_0 + treatment, data=fd)))
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 3.0529788 0.036105062 84.55819 0
## glucose_0 1.1953072 0.003574099 334.43596 0
## treatmenttr 0.9911134 0.007155790 138.50511 0
fake data wide to long
wide_to_long <- function(
dt, #data.table,
measure_prefix = "glucose"
){
# measure _prefix is the prefix of the measurement columns that will be melted. A "_" between the prefix and a time value is assumed. So with measure vars like glucose_0, glucose_15, glucose_20, the measure prefix is "glucose"
dt <- data.table(dt)
dt_long <- melt(dt,
id.vars=c("treatment", "id"),
measure.vars=patterns(paste0(measure_prefix, "_")),
variable.name = "time",
value.name = measure_prefix)
return(dt_long)
}
Fit model functions
two-way anova
two_way <- function(dt_long){
fit <- lm(glucose ~ time*treatment, data=dt_long)
return(fit)
}
repeated measures anova
rmanova <- function(dt_long){
fit <- aov_4(glucose ~ time*treatment + (time|id),
data=dt_long)
return(fit)
}
linear model with baseline as covariate
lm_cov <- function(dt){
fit <- lm(glucose_1 ~ glucose_0 + treatment, data = dt)
return(fit)
}
linear mixed model
lmm <- function(dt_long){
fit <- lme(glucose ~ time*treatment,
random = ~1|id,
data = dt_long,
weights = varIdent(form= ~ 1 | time),
correlation= corSymm(form=~ 1 | id))
return(fit)
}
cLDA functions
Two equivalent functions for CLDA
clda-1
clda1 <- function(dt_long){
design <- model.matrix( ~ time + treatment:time, data = dt_long)
# remove intercept column and effect of tr at time 0
X <- design[, -c(1, which(colnames(design) == "timeglucose_0:treatmenttr"))]
colnames(X)[2] <- "timeglucose_1_treatmenttr"
dt_long_x <- cbind(dt_long, X)
form <- formula(paste0("glucose ~ ", paste(colnames(X), collapse = " + ")))
fit <- gls(form,
data = dt_long_x,
weights = varIdent(form= ~ 1 | time),
correlation= corSymm(form=~ 1| id))
return(fit)
}
clda-2
clda2 <- function(dt_long){
dt_clda <- copy(dt_long)
dt_clda[, time.treatment := ifelse(time != "glucose_0" & treatment=="tr", paste0(time, ":tr"), "cont")]
dt_clda[, time.treatment := factor(time.treatment, c("cont","glucose_1:tr"))]
fit <- gls(glucose ~ time + time.treatment,
data = dt_clda,
weights = varIdent(form= ~ 1 | time),
correlation= corSymm(form=~ 1| id))
return(fit)
}
test functions
Some equivalents
- cLDA is equivalent estimate to the linear model with baseline covariate but has a smaller standard error.
- the two-way (fixed) ANOVA and lmm have equivalent estimates but SE is larger
- the lmm and rmanova have the same p-value (assuming sphericity)
fd <- generate_pre_post(
n = 6,
sigma_0 = 1,
sigma_1 = 1,
rho = 0.6,
beta_0 = 10,
beta_1 = 1
)
fd_long <- wide_to_long(fd,
measure_prefix = "glucose"
)
m1 <- lm_cov(fd)
m2 <- clda1(fd_long)
m3 <- clda2(fd_long)
m4 <- lmm(fd_long)
m5 <- two_way(fd_long)
m6 <- rmanova(fd_long)
linear model with baseline covariate
coef(summary(m1))
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 9.4423880 3.3526784 2.816372 0.02016613
## glucose_0 0.5799923 0.3490826 1.661476 0.13098439
## treatmenttr 0.7087883 0.4448445 1.593340 0.14554812
cLDA (both R methods)
coef(summary(m2))
## Value Std.Error t-value p-value
## (Intercept) 9.6663085 0.1921116 50.316108 2.223746e-23
## timeglucose_1 5.3824640 0.3053176 17.629063 4.601669e-14
## timeglucose_1_treatmenttr 0.7087883 0.4164331 1.702046 1.035060e-01
coef(summary(m3))
## Value Std.Error t-value p-value
## (Intercept) 9.6663085 0.1921116 50.316108 2.223746e-23
## timeglucose_1 5.3824640 0.3053176 17.629063 4.601669e-14
## time.treatmentglucose_1:tr 0.7087883 0.4164331 1.702046 1.035060e-01
two-way (fixed effect) linear model
coef(summary(m5))
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 9.5630065 0.3101326 30.8352174 2.449397e-18
## timeglucose_1 5.4258517 0.4385937 12.3710192 7.923275e-11
## treatmenttr 0.2066040 0.4385937 0.4710601 6.426952e-01
## timeglucose_1:treatmenttr 0.6220131 0.6202652 1.0028179 3.279282e-01
linear mixed model
coef(summary(m4))
## Value Std.Error DF t-value p-value
## (Intercept) 9.5630065 0.2811776 10 34.0105547 1.142426e-11
## timeglucose_1 5.4258517 0.3172619 10 17.1021224 9.855274e-09
## treatmenttr 0.2066040 0.3976452 10 0.5195688 6.146692e-01
## timeglucose_1:treatmenttr 0.6220131 0.4486761 10 1.3863299 1.957756e-01
repeated measures ANOVA
summary(m6)
##
## Univariate Type III Repeated-Measures ANOVA Assuming Sphericity
##
## Sum Sq num Df Error SS den Df F value Pr(>F)
## (Intercept) 3770.9 1 8.5222 10 4424.7551 1.436e-14 ***
## treatment 1.6 1 8.5222 10 1.8863 0.1996
## time 197.5 1 3.0197 10 653.9468 1.919e-10 ***
## treatment:time 0.6 1 3.0197 10 1.9219 0.1958
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
simulations
single post time point (“pre-post”)
simulate_pre_post <- function(
niter = 1000, # number of iterations
n = 6, # if vector then sample per group
sigma_0 = 1, # error at time 0
sigma_1 = 1, # error at time 1
rho = 0.6, # correlation between time 0 and 1
beta_0 = 10, # control mean at time 0
beta_1 = 1, # treatment effect at time 1
beta_2 = 5 # time effect at time 1
){
if(length(n) == 1){n <- rep(n,2)} # set n = n for all groups
method_list <- c("lm_cov", "clda", "lmm", "rmanova")
prob_wide <- data.table(matrix(-9999, nrow=niter, ncol=length(method_list)))
colnames(prob_wide) <- method_list
for(iter in 1:niter){
fd <- generate_pre_post(
n = n,
sigma_0 = sigma_0,
sigma_1 = sigma_1,
rho = rho,
beta_0 = beta_0,
beta_1 = beta_1
)
fd_long <- wide_to_long(fd,
measure_prefix = "glucose"
)
m1 <- lm_cov(fd)
m2 <- clda1(fd_long)
m3 <- clda2(fd_long)
m4 <- lmm(fd_long)
m5 <- two_way(fd_long)
m6 <- rmanova(fd_long)
prob_wide[iter, lm_cov := coef(summary(m1))["treatmenttr", "Pr(>|t|)"]]
prob_wide[iter, clda := coef(summary(m2))["timeglucose_1_treatmenttr", "p-value"]]
prob_wide[iter, lmm := coef(summary(m4))["timeglucose_1:treatmenttr", "p-value"]]
prob_wide[iter, rmanova := summary(m6)$univariate.tests["treatment:time", "Pr(>F)"]]
}
prob <- melt(prob_wide,
id.vars = NULL,
measure.vars = method_list,
variable.name = "method",
value.name = "p_value")
return(prob)
}
Summary statistics
p_summary <- function(prob, niter){
prob_summary <- prob[, .(freq_lt_05 = sum(p_value < 0.05)/max(niter)),
by = .(method)]
return(prob_summary)
}
Plot:
plot_it <- function(prob){
jco_pal <- pal_jco()(6)
group_colors <- jco_pal[c(2,5,4,6)]
group_shapes <- c(15, 16, 17, 18)
pd <- position_dodge(0.8)
gg1 <- ggplot(data = prob,
aes(x=method, y=freq_lt_05, color=method, shape=method)) +
geom_point(position = pd) +
scale_color_manual(values = group_colors) +
scale_shape_manual(values = group_shapes) +
ylab("Frequency p < 0.05") +
xlab("") +
theme_pubr() +
theme(legend.position="none") +
guides(col = guide_legend(ncol = 5, byrow = FALSE)) +
NULL
return(gg1)
}
Type I error
# parameters of simulation
niter = 1000 # number of iterations
n = 6 # if vector then sample per group
sigma_0 = 1 # error at time 0
sigma_1 = 1 # error at time 1
rho = 0.6 # correlation between time 0 and 1
beta_0 = 10 # control mean at time 0
beta_1 = 0 # treatment effect at time 1
beta_2 = 5 # time effect at time 1
prob_type1 <- simulate_pre_post(niter = niter,
n = n,
sigma_0 = sigma_0,
sigma_1 = sigma_1,
rho = rho,
beta_0 = beta_0,
beta_1 = beta_1,
beta_2 = beta_2)
prob_type1_sum <- p_summary(prob_type1, niter)
Power
# parameters of simulation
niter = 1000 # number of iterations
n = 6 # if vector then sample per group
sigma_0 = 1 # error at time 0
sigma_1 = 1 # error at time 1
rho = 0.6 # correlation between time 0 and 1
beta_0 = 10 # control mean at time 0
beta_1 = 1 # treatment effect at time 1
beta_2 = 5 # time effect at time 1
prob_power <- simulate_pre_post(niter = niter,
n = n,
sigma_0 = sigma_0,
sigma_1 = sigma_1,
rho = rho,
beta_0 = beta_0,
beta_1 = beta_1,
beta_2 = beta_2)
prob_power_sum <- p_summary(prob_power, niter)
Tables
Type I error rates
table1 <- prob_type1_sum
colnames(table1)[2] <- "Type I error rate"
knitr::kable(table1)
| method | Type I error rate |
|---|---|
| lm_cov | 0.055 |
| clda | 0.099 |
| lmm | 0.040 |
| rmanova | 0.040 |
Power
table2 <- prob_power_sum
colnames(table2)[2] <- "Power"
knitr::kable(table2, digits = 2)
| method | Power |
|---|---|
| lm_cov | 0.43 |
| clda | 0.57 |
| lmm | 0.41 |
| rmanova | 0.41 |
Plots
gg_a <- plot_it(prob_type1_sum)
gg_b <- plot_it(prob_power_sum)
plot_grid(gg_a, gg_b, ncol=2)


Ingredients:
| Amount | Ingredient | |
|---|---|---|
| ¾ cup + 2 tablespoons | Almond milk | |
| 1 tablespoon | Apple cider vinegar | |
| 1 cup | All-purpose flour | |
| 1 tablespoon | Baking powder | |
| Generous pinch | Salt | |
| 1 tablespoon | Cooking oil | |
| 2 tablespoons | Maple syrup | |
| 1 teaspoon | Vanilla extract |
Instructions:
| 1. | In a bowl, combine milk and vinegar. Let sour while you combine other ingredients. | |
| 2. | In a mixing bowl, combine flour, baking powder, and salt. Stir in oil, maple syrup, vanilla, and sour milk, stirring just until combined. Don't over-stir as this creates tough pancakes. | |
| 3. | Lightly grease a non-stick pan or griddle and place over medium heat. When hot, add pancake batter flipping after a minute or so, when edges are set and a few bubbles appear at the surface. Makes 6–8 pancakes, depending on how big you make them. |


This app blocks or reacts to unwanted calls on a rule-based logic. The main-home activity controls the turning on and off of a service that listens to incoming calls. This service is sticky and survives crashes and reboots of the system.
When an incoming call is detected, the service loops through the list of active filters, and for each filter, if there is a match, an action is performed, like dropping the call, logging the event or sending a warning Toast message. Hence central to this design is the definition of a filter object.
A filter is assembled by combining two rules and one action objects: a calendar rule to define when the filter is active, a filter rule to define the numbers and patterns against which the incoming call is matched and an action to be performed when the filter is active and there is a match.
Filters can be created and edited (changed and deleted) using the "Show active filters" in the menu drop-down inside the action bar. This functionality allows to create a new filter or to modify an existing one. Calendar rules and filter rules can be created independently and then assembled into a filter or can be created directly when creating the filter. It is important to notice that all filters shown by the action "Show active filters" will be used by the service when an incoming call is detected.
Here is a list of all menu items available from the drop-down menu:
Once the service is running, the main activity's page also shows a brief statistics of the total number of calls received and triggered events, i.e. when the filter reacted by performing an action, since service start. These statistics are displayed on top of two buttons that allow to navigate directly to the relevant logs: the latest calls received and latest calls that triggered an action, respectively.


{% extends "secondary.html" %}
{% block content %}
Oh dear. It appears you have wandered onto a page that does not exist. How do you do that?
Probably a glitch.
At any rate, click on one of those links to the right, or on the cool title at the top if you'd like to have a look around.


Synopsis
“Advertising is the art of convincing
people to spend money they don't have for
something they don't need.”
-Will Rogers
Very rightly said, an advertisement must be
something that sells the product without
bringing attention to itself.
Refraining from advertisement and trying to sell
is like winking at a GIRL in dark.
Do you think you have that creative intellect in
you so as to understand the making of an
Advertisement?
Do you suppose you can create an avant-garde
advertisement to make your product a new
favorite among people?
Ad-Venture is yours!
Rules & Instructions
Round 1 –
Teams have to present an ad on any ‘topic’,
‘concept’, ‘idea’, ‘product’ chosen by them
beforehand.
Round 2 –
Finalists will be given a random ‘topic’,
‘concept’, ‘idea’ or ‘product’ to prepare an ad
on it with maximum 15 minutes of preparation
time,
Instructions
1. Any instance of ‘copying’ of an existing ad
would not be tolerated and team be disqualified.
2. Any instance of entire ‘copying’ an existing
concept would lead to disqualification of team,
and if used, it must clearly impart the
difference.
3. An ad must not go
beyond 2 minutes.
4.
An ad must not pass an offensive message.
Team Format
1.
Team needs to register online for the event
2.
Team can consist of a maximum of
four
members
3.
The members of a team need not be from the same
college
4.
All Students with valid ID cards of their
educational institutes are eligible to
participate
5.
The
organizers’ decision pertaining to
implementation of rules shall be final.
Synopsis
i.
“Risk
is in not knowing what you are doing”.
-Warren Buffet
Dwelling into the stock market requires a cool
mind and the use of common sense. Markets test
patience and reward conviction.
Everyone has the brain power to make money, but
few have the stomach.
Do you think you can create fortune in 30
minutes? Can you rightly control you audacity?
Then you are surely the next Warren Buffet!
Welcome to Bulls & Bears, a virtual stock market
extravaganza!
ii.
Rules and Instructions
o
1. Teams will be given ‘30’ minutes to carry out
transactions.
o
2. A broker will be shared
between two teams.
o
3. Teams will be given a
specific amount of virtual money to buy shares
with.
o
4. Teams will be doing
trade on a ‘Virtual Trade Market’ with virtual
companies.
o
5. Share prices will be
fluctuation as per virtual market trends.
o
6. Other rules will be
explained on the spot.
o
7. Top ‘3’
teams having maximum cash from each round will
be selected for the final round.
Team Format
o
1.
Team should consist of 2 players.
o
2.
Teams have to register on the spot.
o
3.
Participants from a team need not be from the
same college.
o
4. Those
with a valid identity card from their respective
educational institute are eligible to
participate.
o
5.
The organizers reserve the rights to
change any or all of the above rules as they
deem fit. Change in rules, if any will be
highlighted on the website.
Synopsis
i.
“You can only sell a
product if you understand and believe in it”
–Anon
ii.
Does selling fascinate you? Do you have enough
mettle to go out on the streets and trade with
no limits?
iii.
Coz it’s not a kid’s job, only those who are
smart enough to pick up correct opportunities
are suggested to take part!
iv.
Turn the streets into business hot zones!
v.
Rules & Instructions
i.
Round 1 –
Teams will have to sit for a biz-quiz. Topics
will be of a wide variety (mostly current &
recent happenings).
ii.
iii.
Round 2 –
Shortlisted teams will be given a stipulated
amount of money with which they have to go on
streets and make profit by any means.
iv.
v.
- Teams will have to
adhere to some rules of the event, as will be
explained on the spot.
vi.
- Teams caught violating
the rules will face disqualification.
Team Format
1.
Teams must contain 3 participants each.
2.
Teams can register online and on-the-spot
(online preferred).
3.
It is not necessary that the participants
forming a team should be from the same college.
4.
All students with a valid identity card of their
respective educational institutes are eligible
to participate.
5.
Final decision will be of the organizers. Change
in rules will be reflected on the website,
Synopsis
i.
“A real man creates business, creates
opportunities, creates enterprises, creates
legends that people love to work for”.
ii.
–Anon
iii.
“I am finally an ‘Entrepreneur’, that’s what you
are called when you don’t have a job!”
iv.
–Ted
Turner
v.
 Do you have a vigorous
business plan in mind that you think might reap
great rewards?  Do you have the spunk to start
from scratch and make it super big?
Presenting to you, ENVISAG!
vi.
A platform where you will be able to put up your
revolutionary ideas in the form of a
Business
Presentation. A business model that focuses
on issues like profitability, value-for-money,
innovativeness, sustainability, etcetera.
vii.
Winner’s in for a treat!
viii.
Rules & Instructions
i.
To be announced soon!
ii.
Team Format
i.
To be announced soon!
ii.
Synopsis
i.
India has been a pioneering force in shaping the
world economy. What was thought not possible 20
years back is possible now! There were problems
predicted for the future years back, many of
them have been taken care of!
ii.
But today we will see ourselves 13 years down
the line in the year 2025! What could be the
possible major problems of the year 2025? Its
time to think, because implementation cannot
come if there is no thinking about the issues!
So think!
iii.
And just like an
Ocean
retains its identity, no matter what all rivers
dump into it, present your ideas in
Ocean - Think,
a platform over which you can discuss challenges
of the future, provide solutions to it, have a
demanding debate and spend a fruitful afternoon,
but ultimately making sure that this country of
our resemblances an Ocean!
Budding thinkers! Welcome!
Rules & Instructions
Synopsis
i.
The name is self-sufficient!
i.
Every MBA aspirant aims at scoring well in the
much competitive Common Admission Test (CAT). So
for you, in association with
Triumphant Institute of Management Education
(TIME), Surat,
we have an Online Mock CAT Examination.
ii.
For those who have completed their CAT prep,
check your standing!
iii.
For those who are preparing for CAT, foresee
what comes.
Rules & Instructions
1.
The test will be taken on a computer, simulating
the actual test pattern.
2.
The number of question and the duration of the
test will be conveyed soon.
Registration
1.
Individuals
can register on-line as well as on the spot
(online is preferred).
Synopsis
i.
Does the present political
scenario make you feel frustrated? Do you think
work is not being done genuinely? Do you have
that desire to do something desperately?
Participate in politikicks!!
Become a self-made politician. Present and frame
laws and debate with your oppositions on
contemporary and controversial topics.
Rules & Instructions
i.
Round 1:
ii.
Teams would have to take a
quiz.
Topics for the quiz will be purely political,
with more emphasis on recent and current
political activities.
iii.
Round
2:
iv.
To be announced.
v.
Round 3:
vi.
Six teams would be shortlisted for the final
round. A mini-parliament session will commence.
vii.
How the session will proceed and on what topic
will be informed soon.
Team
Format
1.
Teams must contain 3
participants each.
2.
Teams have to register online.
3.
It is not necessary that
the participants forming a team should be from
the same college.
4.
All
students with a valid identity card of their
respective educational institutes are eligible
to participate.
5.
Final decision will be of the organizers. Change
in rules will be reflected on the website.
Synopsis
i.
It
takes a master strategist to understand the
combination of a 'movie's' ingenuity and
commercialism. It takes more than a regular
Uncle Sam to question, admire, explore and
present critics on a movie.
Do you have the acumen to interpret?
Do you have the creativity to express your
judgment?
Then you have come to the right place,
congratulations!
Rules & Instructions
Round 1:
Participants have to present a critic on any one
of the library of movie whose list will be
uploaded soon. Criteria for judging will too be
uploaded soon. Entries would have to be mailed
at the given e-mail address.
Round 2:
Short listed entries from the first round would
be invited over to the festival venue. Each team
would be shown a part of a randomly picked up
movie from a selected lot. A part of the movie
would be screened which the finalists have to
watch and critic on it in a stipulated amount of
time.
Other details regarding the duration, time
limit, word limit, submission deadline, etcetera
would be uploaded soon.
Team Format
1.
Teams must contain 2 or 3 participants each.
2.
Teams have to register online.
3.
It is not necessary that the participants
forming a team should be from the same college.
4.
All students with a valid identity card of their
respective educational institutes are eligible
to participate.
5.
Final decision will be of the organizers. Change
in rules will be reflected on the website.
finalists will be shows a short clip of any movie over which they have to present a critic.
TBA


BLOG 16: The "Perfect" Question
SUNDAY, 6/28/2015
As someone who is relatively new to programming I have at times (actually, more often that not) needed help and guidance with my learning. When I cannot get help from classmates and friends, I usually resort to a good ol' google search. I am usually pointed towards a similar topic on Stack Overflow:
"... a question and answer site for professional and enthusiast programmers."
During my last 9 weeks of highs and lows, I have turned to peers, friends and the interweb for help and guidance. In my belief there is no such thing as a "perfect" question, only near-perfect as anything can be improved. However, you must understand that there are very important elements when asking such a question.
- Context
- This includes the language/framework in question, the problem/error, original poster's (OP) code, the goal the OP is trying to achieve
- Thoughts behind error
- An OP should not post a question to just receieve an answer. He/she should post a question to help understand/solidify the concept in question
- Therefore, it should be in good practice to prompt a reasoning behind the original code
- If you can, it may be good to supply a direction in which you think the error/problem can be fixed
- Feedback
- Regardless of if you are using a question/answer website or not, a person should always stay involved with the discussion
- There are many times where you take the first solution you see, but understanding that there can be multiple ways to solve your problem will help you avoid further similar problems down the road
- More Questions
- When still confused and in doubt, ask away!
- It is never wrong to keep on asking
When using resource websites like Stack Overflow, I think it is important to not select a solution just because it is a solution. Be patient and try to understand why that person decided to use those methods/functions/classes/etc. When one has deadlines or has been working on a solution for most of the day, it can be easy to just select the first thing that pops up. I have done this a couple times during my early weeks of DBC, and learned fast that is the worst thing you can do.
These are just a few of the elements that I believe is important for the near "perfect" question. It is by no means limited to these several elements, but in my opinion are quite important to the way I try to get help. TAKE YOUR TIME.  AND IF YOU ARE STILL CONFUSED, ASK ANOTHER 'PERFECT' QUESTION!


Date Attended: 2021 July to date
Date Attended: 2016 to 2020
Date Attended: 2012 to 2015
Date Attended: 2012 to 2015
May 2019 to July 2019
Title: Attaché
Duties
August 2019
Title: Enumerator
Duties
January 2016 to August 2016
Title: Peer Teacher
Duties
Unlike previously, when the world was ruled using Pen and Paper,
Today's world is operated using a Keyboard and a Mouse
To fit in and remain relevant & productive,
it is imperative to understand how to communicate with computers which is only possible with the help of programming languages
| # | Project Title | Technologies used | Description | Deployed Link |
|---|---|---|---|---|
| 1. | Street Food Website | HTML & CSS | This is a static webpage that can be customized for use in the food and beverage industry | LIVE LINK |
| 2. | Photography Website | HTML & CSS | This project presented a few favourite photos of places i have visited | LIVE LINK |
| 3. | Relocation Express Website | HTML & CSS | This is a website for a Relocation company. For more, click the live link | LIVE LINK |
© Copyright 2021 Kevson


Right now, the prevailing theory of how the universe came about is commonly called the Big Bang theory.
And really is just this idea that the universe started as kind of this infinitely small point, this infinitely small singularity.
And then it just had a big bang or it just expanded from that state to the universe that we know right now.
And when I first imagined this-- and I think if it's also a byproduct of how it's named-- Big Bang, you kind of imagine this type of explosion, that everything was infinitely packed in together and then it exploded.
And then it exploded outward.
And then as all of the matter exploded outward, it started to condense.
And then you have these little galaxies and super clusters of galaxies.
And they started to condense.
And then within them, planets condensed and stars condensed.
And then we have the type of universe that we have right now.
But this model for visualizing the Big Bang has a couple of problems.
One is when we talk about the Big Bang, we're not talking about the matter, just the mass or just the matter in the universe being in one point.
We're talking about actual space expanding.
So we're not just talking about something inside of space, like the physical mass, the physical matter expanding.
We're talking about space itself.
And so when you have this type of model, you have all of this stuff expanding.
But you're like, whoa, look, isn't it expanding into something else? Maybe if the furthest out parts of this matter is right over here, what's this stuff over here? And so you say, well, wouldn't that be space? So how can you say space itself is expanding? And another idea that a Big Bang also implies is if this is the furthest stuff out there, would this be the edge of the universe? Does the universe have an edge? And the answer to either of those questions, and that's what we're going to try to tackle in this, is that, one, the universe does not have an edge.
And two, there is no outside space.
We are not expanding into another space.
And I'm going to explain that.
Hopefully, we'll see why that is the case right now.
So the best way to view it-- and we're going to view it by analogy.
If I were tell you that I have a two-dimensional space that has a finite area, so it has a finite area-- so it's not infinite.
And it also has no edge.
This once again, when you first look at it, seems difficult.
How do I just construct something that has a finite area, but still has no edge? Every time I try to draw an area, it looks like I have to have some edges.
And then you might remember, what if that two-dimensional space is curved, what happens? And I think the easiest example of that is the surface of a sphere.
Let me draw a sphere over here.
So this right here is a sphere.
Let me draw some longitude and latitudinal lines on this sphere.
On this sphere, all of a sudden-- and I'll shade it in a little bit, make it look nice-- this type of a sphere, you have a finite area.
You could imagine the surface of a balloon, or the surface of a bubble, or the surface of the Earth.
You have a finite area, but you have no edge.
If you keep going forever in one direction, you're going to go all the way around and come back to the other side.
Now, to imagine a three-dimensional space that has these same properties, a finite area and-- and I don't want to say finite area anymore, because we're not talking about a three-dimensional space.
Let me draw it over here.
So let's think about a three-dimensional space, so a three-dimensional space.
Instead of area, since we're in three dimensions now, I want to talk about a finite volume and no edge.
How do I do that? And when you think about it superficially, well, look, if I have a finite volume, maybe it'll be contained in some type of a cube.
And then we clearly have edges in those situations.
Or you could even think about a finite volume as being the inside of a sphere.
And that clearly has an edge, this entire surface over there.
So how do you construct a three-dimensional space that has a finite volume and no edge? And that I'm going to tell you right now, it's very hard for us to visualize it.
But in order to visualize it, I'm essentially going to draw the same thing as I drew right here.
What you have to imagine, and you almost have to imagine it by analogy, unless you have some type of a profound brain wired for more than three spatial dimensions, is a sphere.
So let me make it clear.
This is a two-dimensional surface.
On the surface of the sphere, you can only move into directions, two perpendicular directions.
You could move like that or you could move like that.
You could move left and right or you could move up and down.
So it's a two-dimensional surface of a three-dimensional sphere.
So if we take it by analogy, let's imagine, and it's hard to imagine, a three-dimensional surface.
And you can do it mathematically.
The math here is actually not that difficult.
It's a three-dimensional surface of a four-dimensional sphere.
And I'm going to draw it the same way.
So if we kind of view those three dimensions are just these two dimensions of the surface, the same thing.
It's the same thing.
And if you imagine that-- I'm not saying that this is actually the shape of the universe.
We don't know the actual shape.
But we do know that it does have a slight curvature.
We don't know the actual shape, but a sphere is the simplest.
There's other ones we could do.
A toroid would also fit the bill of having a finite volume with no edge.
And another thing, I want to make it clear, we actually don't even know whether it has just a finite volume.
That's still an open question.
But what I want to do is show you that it can have a finite volume and also have no edge.
And most people believe-- and I want to say \ here because we can just go based on evidence and all that-- that we are talking about something with a finite volume, especially when you talk about the Big Bang theory.
That kind of, on some dimension, implies a finite volume, although it could be a super large, unfathomably large volume, it is finite.
Now, if you have this, let's imagine this sphere.
Let's imagine this sphere.
Once again, if you're on this surface of this four-dimensional sphere-- I obviously can not draw a four-dimensional sphere.

If you go that way, you'll come back around here.
Now, the universe is super huge.
So even light, maybe light itself will take an unbelievable amount of time to traverse it.
And if this sphere itself is expanding, it might be expanding so fast that light might not ever be able to come back around it.
But in theory, if something were fast enough, if something were to keep going around, it could eventually go back to this point.
Now, when we talk about a three-dimensional surface-- it's a three-dimensional surface of a four-dimensional sphere-- that means that any of the three dimensions-- over here, on the surface, I can only draw two.
But that means if this is true, if the universe is a three-dimensional surface of a four-dimensional sphere, that means that if you go up and you just keep going up, you'll eventually come back from the bottom.
So if you keep going all the way up, you'll eventually come back to the point that you were.
It might be an unbelievably large distance, but you'll eventually get back where you were.
If you go to the right, you'll eventually come back all the way around to the point where you were.
And if you were to go into the page-- so if you were to go into the page-- let me draw it that way-- if you go into the page, you would eventually come back from above the page and come back to the point that you are.
So that's what this implication would be.
That you would eventually get back to where you are.
So let's go back to the question of an expanding universe, a expanding universe that's not expanding into any other space.
That is all of the space, but it's still expanding.
Well, this is the model.
So you could imagine shortly after the Big Bang, our four-dimensional sphere looked like this.
Maybe it was a little small four-dimensional sphere.

Then a little bit later, it's this larger sphere.
Let me just shade it in to show you that it's kind of popping out of the page, that's it's a sphere.
And then at a later time, the sphere might look like this.
The sphere might look like this.
Now, your temptation might be to say, wait, Sal, isn't this stuff outside of this sphere, isn't that some type of a space that it's expanding into? Isn't that somehow part of the universe? And I would say if you're talking in three dimensions, no, it's not.
The entire universe is this surface.
It is this surface of this four-dimensional sphere.
If you start talking about more dimensions, then, yes, you could talk about maybe things outside of our three-dimensional universe.
So as this expands in space/time-- so one way to view the fourth dimension is it is time itself-- things are just getting further and further apart.
And I'll talk about more evidence in future videos for why the Big Bang is the best theory we have out there right now.
But as you could imagine, if you have two points on this sphere that are that far apart, as this sphere expands, this four-dimensional sphere, as this bubble blows up or this balloon blows up, those two points are just-- let me draw three points.
Let's say those are three points.
Those three points are just going to get further and further apart.
And that's actually one of the main points that-- or one of the first reasons why it made sense to believe the Big Bang-- is that everything is expanding, not from some central point.
But everything is expanding from everything.
That if you go in any direction from any point in the universe, everything else is expanding away.
And the further away you go, it looks like the faster it's expanding away from you.
So I'll leave you there, something for you to kind of think about a little bit.
And then we'll build on some of this to think about what it means to kind of observe the observable universe.


--- tags: - data - economy - tax author: display_name: JP email<EMAIL_ADDRESS>date: 2011-11-18 15:34:32 -0700 categories: [] SalesTaxAreas: hub: name: Utah Sales Tax Zones item_id: 852bc8eeaa534cc586b8936e1b451f54 updates: - Updated 2/13/2023 1st Quarter 2023 - Updated 8/25/2022 3rd Quarter 2022 - Updated 4/12/2022 2nd Quarter 2022 - Updated 1/31/2019 1st Quarter 2019 TaxEntities: hub: name: Utah Tax Entities 2022 item_id: cf717be2436e46758a263d53b63b8cf7 updates: - June 2023 - March 2022 - January 2021 TaxAreas: hub: name: Utah Tax Areas 2022 item_id: 1c962302668e431db53d9763962c09f5 updates: - June 2023 - March 2022 - January 2021 TransitSpecialTaxAreas: hub: name: Utah Transit Special Tax Areas item_id: 17b06b8c22444f0291703c4c05f18b07 updates: - March 2022 - January 2019 - March 2018 --- {% include abstract.html name="Sales Tax Areas and Tax Entity Areas" stewards="USTC & UGRC" abstract="These datasets are related to taxation in Utah. They were created by the Utah State Tax Commission (USTC) and other local government agencies." %}
Sales Tax Areas contains the approximate boundaries of Sales Tax Collection Areas in Utah. Sales Tax Areas are formed by municipality boundaries, special sales tax districts and the unincorporated areas of counties not in a special sales tax district.
{% include contact.html subject=page.title contact=site.data.contacts.agrc %}
Tax Areas 2022 contains the set of taxing areas for the year, formed by each unique 2-dimensional intersection of incorporated taxing entities in Utah. Each taxing area represents at least a county and school district as members of these two categories cover the entire state. The property tax levy rate within a tax area should be the same for a specified property type within that area. Rates for 2023 have not been assigned yet, that data will not be available until September.
There are no constraints or warranties with regard to the use of this dataset.
{% include contact.html subject=page.title contact=site.data.contacts.tax %}
Transit Sales Tax Areas are generally areas outside of incorporated municipalities where additional sales tax is collected to support transit activities (generally buses).
{% include contact.html subject=page.title contact=site.data.contacts.special_tax %}
Tax Entities 2022 contains Tax Entities in Utah. Tax Entities are incorporated bodies that have the power to levy a local property tax such as school districts, counties, cities, special service districts, redevelopment districts, library districts, cemetery districts, and mosquito abatement districts. The Tax Entities 2022 dataset does not represent exact legal boundaries, but rather a set of boundaries used for the administrative purposes by the USTC Property Tax Division for centrally assesses properties (quarries, rail, linear utilities, etc).
1010
are counties
2000
level ENT_NBR are school districts
3000
level ENT_NBR are incorporated cities/towns
4000
level ENT_NBR are special service districts
6000
level ENT_NBR are special districts
8000
and 9000
level ENT_NBR are redevelopment or community
development areas (RDA or CDA)
{% include contact.html subject=page.title contact=site.data.contacts.tax %}