001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018 019 package org.apache.hadoop.filecache; 020 021 import java.io.File; 022 import java.io.IOException; 023 import java.net.URI; 024 025 import org.apache.hadoop.classification.InterfaceAudience; 026 import org.apache.hadoop.classification.InterfaceStability; 027 import org.apache.hadoop.conf.Configuration; 028 import org.apache.hadoop.fs.FileStatus; 029 import org.apache.hadoop.fs.FileSystem; 030 import org.apache.hadoop.fs.Path; 031 import org.apache.hadoop.mapreduce.MRJobConfig; 032 033 /** 034 * Distribute application-specific large, read-only files efficiently. 035 * 036 *
DistributedCache is a facility provided by the Map-Reduce 037 * framework to cache files (text, archives, jars etc.) needed by applications. 038 *
 039 * 040 *
Applications specify the files, via urls (hdfs:// or http://) to be cached 041 * via the {@link org.apache.hadoop.mapred.JobConf}. The 042 * DistributedCache assumes that the files specified via urls are 043 * already present on the {@link FileSystem} at the path specified by the url 044 * and are accessible by every machine in the cluster.
 045 * 046 *
The framework will copy the necessary files on to the slave node before 047 * any tasks for the job are executed on that node. Its efficiency stems from 048 * the fact that the files are only copied once per job and the ability to 049 * cache archives which are un-archived on the slaves.
 050 * 051 *
DistributedCache can be used to distribute simple, read-only 052 * data/text files and/or more complex types such as archives, jars etc. 053 * Archives (zip, tar and tgz/tar.gz files) are un-archived at the slave nodes. 054 * Jars may be optionally added to the classpath of the tasks, a rudimentary 055 * software distribution mechanism. Files have execution permissions. 056 * In older version of Hadoop Map/Reduce users could optionally ask for symlinks 057 * to be created in the working directory of the child task. In the current 058 * version symlinks are always created. If the URL does not have a fragment 059 * the name of the file or directory will be used. If multiple files or 060 * directories map to the same link name, the last one added, will be used. All 061 * others will not even be downloaded.
 062 * 063 *
DistributedCache tracks modification timestamps of the cache 064 * files. Clearly the cache files should not be modified by the application 065 * or externally while the job is executing.
 066 * 067 *
Here is an illustrative example on how to use the 068 * DistributedCache:
 069 *

 070 * // Setting up the cache for the application 071 * 072 * 1. Copy the requisite files to the FileSystem: 073 * 074 * $ bin/hadoop fs -copyFromLocal lookup.dat /myapp/lookup.dat 075 * $ bin/hadoop fs -copyFromLocal map.zip /myapp/map.zip 076 * $ bin/hadoop fs -copyFromLocal mylib.jar /myapp/mylib.jar 077 * $ bin/hadoop fs -copyFromLocal mytar.tar /myapp/mytar.tar 078 * $ bin/hadoop fs -copyFromLocal mytgz.tgz /myapp/mytgz.tgz 079 * $ bin/hadoop fs -copyFromLocal mytargz.tar.gz /myapp/mytargz.tar.gz 080 * 081 * 2. Setup the application's JobConf: 082 * 083 * JobConf job = new JobConf(); 084 * DistributedCache.addCacheFile(new URI("/myapp/lookup.dat#lookup.dat"), 085 * job); 086 * DistributedCache.addCacheArchive(new URI("/myapp/map.zip", job); 087 * DistributedCache.addFileToClassPath(new Path("/myapp/mylib.jar"), job); 088 * DistributedCache.addCacheArchive(new URI("/myapp/mytar.tar", job); 089 * DistributedCache.addCacheArchive(new URI("/myapp/mytgz.tgz", job); 090 * DistributedCache.addCacheArchive(new URI("/myapp/mytargz.tar.gz", job); 091 * 092 * 3. Use the cached files in the {@link org.apache.hadoop.mapred.Mapper} 093 * or {@link org.apache.hadoop.mapred.Reducer}: 094 * 095 * public static class MapClass extends MapReduceBase 096 * implements Mapper<K, V, K, V> { 097 * 098 * private Path[] localArchives; 099 * private Path[] localFiles; 100 * 101 * public void configure(JobConf job) { 102 * // Get the cached archives/files 103 * File f = new File("./map.zip/some/file/in/zip.txt"); 104 * } 105 * 106 * public void map(K key, V value, 107 * OutputCollector<K, V> output, Reporter reporter) 108 * throws IOException { 109 * // Use data from the cached archives/files here 110 * // ... 111 * // ... 112 * output.collect(k, v); 113 * } 114 * } 115 * 116 *

 117 * 118 * It is also very common to use the DistributedCache by using 119 * {@link org.apache.hadoop.util.GenericOptionsParser}. 120 * 121 * This class includes methods that should be used by users 122 * (specifically those mentioned in the example above, as well 123 * as {@link DistributedCache#addArchiveToClassPath(Path, Configuration)}), 124 * as well as methods intended for use by the MapReduce framework 125 * (e.g., {@link org.apache.hadoop.mapred.JobClient}). 126 * 127 * @see org.apache.hadoop.mapred.JobConf 128 * @see org.apache.hadoop.mapred.JobClient 129 * @see org.apache.hadoop.mapreduce.Job 130 */ 131 @SuppressWarnings("deprecation") 132 @InterfaceAudience.Public 133 @InterfaceStability.Stable 134 @Deprecated 135 public class DistributedCache extends 136 org.apache.hadoop.mapreduce.filecache.DistributedCache { 137 /** 138 * Warning: {@link #CACHE_FILES_SIZES} is not a *public* constant. 139 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 140 * use {@link MRJobConfig#CACHE_FILES_SIZES} 141 */ 142 @Deprecated 143 public static final String CACHE_FILES_SIZES = 144 "mapred.cache.files.filesizes"; 145 146 /** 147 * Warning: {@link #CACHE_ARCHIVES_SIZES} is not a *public* constant. 148 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 149 * use {@link MRJobConfig#CACHE_ARCHIVES_SIZES} 150 */ 151 @Deprecated 152 public static final String CACHE_ARCHIVES_SIZES = 153 "mapred.cache.archives.filesizes"; 154 155 /** 156 * Warning: {@link #CACHE_ARCHIVES_TIMESTAMPS} is not a *public* constant. 157 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 158 * use {@link MRJobConfig#CACHE_ARCHIVES_TIMESTAMPS} 159 */ 160 @Deprecated 161 public static final String CACHE_ARCHIVES_TIMESTAMPS = 162 "mapred.cache.archives.timestamps"; 163 164 /** 165 * Warning: {@link #CACHE_FILES_TIMESTAMPS} is not a *public* constant. 166 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 167 * use {@link MRJobConfig#CACHE_FILE_TIMESTAMPS} 168 */ 169 @Deprecated 170 public static final String CACHE_FILES_TIMESTAMPS = 171 "mapred.cache.files.timestamps"; 172 173 /** 174 * Warning: {@link #CACHE_ARCHIVES} is not a *public* constant. 175 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 176 * use {@link MRJobConfig#CACHE_ARCHIVES} 177 */ 178 @Deprecated 179 public static final String CACHE_ARCHIVES = "mapred.cache.archives"; 180 181 /** 182 * Warning: {@link #CACHE_FILES} is not a *public* constant. 183 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 184 * use {@link MRJobConfig#CACHE_FILES} 185 */ 186 @Deprecated 187 public static final String CACHE_FILES = "mapred.cache.files"; 188 189 /** 190 * Warning: {@link #CACHE_LOCALARCHIVES} is not a *public* constant. 191 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 192 * use {@link MRJobConfig#CACHE_LOCALARCHIVES} 193 */ 194 @Deprecated 195 public static final String CACHE_LOCALARCHIVES = 196 "mapred.cache.localArchives"; 197 198 /** 199 * Warning: {@link #CACHE_LOCALFILES} is not a *public* constant. 200 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 201 * use {@link MRJobConfig#CACHE_LOCALFILES} 202 */ 203 @Deprecated 204 public static final String CACHE_LOCALFILES = "mapred.cache.localFiles"; 205 206 /** 207 * Warning: {@link #CACHE_SYMLINK} is not a *public* constant. 208 * The variable is kept for M/R 1.x applications, M/R 2.x applications should 209 * use {@link MRJobConfig#CACHE_SYMLINK} 210 */ 211 @Deprecated 212 public static final String CACHE_SYMLINK = "mapred.create.symlink"; 213 214 /** 215 * Add a archive that has been localized to the conf. Used 216 * by internal DistributedCache code. 217 * @param conf The conf to modify to contain the localized caches 218 * @param str a comma separated list of local archives 219 */ 220 @Deprecated 221 public static void addLocalArchives(Configuration conf, String str) { 222 String archives = conf.get(CACHE_LOCALARCHIVES); 223 conf.set(CACHE_LOCALARCHIVES, archives == null ? str 224 : archives + "," + str); 225 } 226 227 /** 228 * Add a file that has been localized to the conf.. Used 229 * by internal DistributedCache code. 230 * @param conf The conf to modify to contain the localized caches 231 * @param str a comma separated list of local files 232 */ 233 @Deprecated 234 public static void addLocalFiles(Configuration conf, String str) { 235 String files = conf.get(CACHE_LOCALFILES); 236 conf.set(CACHE_LOCALFILES, files == null ? str 237 : files + "," + str); 238 } 239 240 /** 241 * This method create symlinks for all files in a given dir in another 242 * directory. Currently symlinks cannot be disabled. This is a NO-OP. 243 * 244 * @param conf the configuration 245 * @param jobCacheDir the target directory for creating symlinks 246 * @param workDir the directory in which the symlinks are created 247 * @throws IOException 248 * @deprecated Internal to MapReduce framework. Use DistributedCacheManager 249 * instead. 250 */ 251 @Deprecated 252 public static void createAllSymlink( 253 Configuration conf, File jobCacheDir, File workDir) 254 throws IOException{ 255 // Do nothing 256 } 257 258 /** 259 * Returns {@link FileStatus} of a given cache file on hdfs. Internal to 260 * MapReduce. 261 * @param conf configuration 262 * @param cache cache file 263 * @return FileStatus of a given cache file on hdfs 264 * @throws IOException 265 */ 266 @Deprecated 267 public static FileStatus getFileStatus(Configuration conf, URI cache) 268 throws IOException { 269 FileSystem fileSystem = FileSystem.get(cache, conf); 270 return fileSystem.getFileStatus(new Path(cache.getPath())); 271 } 272 273 /** 274 * Returns mtime of a given cache file on hdfs. Internal to MapReduce. 275 * @param conf configuration 276 * @param cache cache file 277 * @return mtime of a given cache file on hdfs 278 * @throws IOException 279 */ 280 @Deprecated 281 public static long getTimestamp(Configuration conf, URI cache) 282 throws IOException { 283 return getFileStatus(conf, cache).getModificationTime(); 284 } 285 286 /** 287 * This is to check the timestamp of the archives to be localized. 288 * Used by internal MapReduce code. 289 * @param conf Configuration which stores the timestamp's 290 * @param timestamps comma separated list of timestamps of archives. 291 * The order should be the same as the order in which the archives are added. 292 */ 293 @Deprecated 294 public static void setArchiveTimestamps(Configuration conf, String timestamps) { 295 conf.set(CACHE_ARCHIVES_TIMESTAMPS, timestamps); 296 } 297 298 /** 299 * This is to check the timestamp of the files to be localized. 300 * Used by internal MapReduce code. 301 * @param conf Configuration which stores the timestamp's 302 * @param timestamps comma separated list of timestamps of files. 303 * The order should be the same as the order in which the files are added. 304 */ 305 @Deprecated 306 public static void setFileTimestamps(Configuration conf, String timestamps) { 307 conf.set(CACHE_FILES_TIMESTAMPS, timestamps); 308 } 309 310 /** 311 * Set the conf to contain the location for localized archives. Used 312 * by internal DistributedCache code. 313 * @param conf The conf to modify to contain the localized caches 314 * @param str a comma separated list of local archives 315 */ 316 @Deprecated 317 public static void setLocalArchives(Configuration conf, String str) { 318 conf.set(CACHE_LOCALARCHIVES, str); 319 } 320 321 /** 322 * Set the conf to contain the location for localized files. Used 323 * by internal DistributedCache code. 324 * @param conf The conf to modify to contain the localized caches 325 * @param str a comma separated list of local files 326 */ 327 @Deprecated 328 public static void setLocalFiles(Configuration conf, String str) { 329 conf.set(CACHE_LOCALFILES, str); 330 } 331 }


We optimize content!
- recontextualize clicks-and-mortar technologies
- evolve dot-com vortals
- incubate e-business methodologies
- synergize seamless deliverables
- reintermediate bricks-and-clicks experiences
- expedite end-to-end interfaces
- mesh 24/7 communities
- iterate value-added methodologies
- engage magnetic functionalities
- recontextualize cutting-edge users
- enable bricks-and-clicks initiatives
- cultivate magnetic communities


Mouse: left button down - rotate, right button down pan, mouse wheel - zoom
The Cheddar Survey "Therion" 3D file by University of Bristol Spelaeological Society is released under a
Creative Commons license.
Contains Ordnance Survey data © Crown copyright and database right 2015.
Contains DTM data © Environment Agency copyright and/or database right 2015.


Hey there, I'm metrics! Code: {{code}}. State: {{state}}. Status: {{status_code}}. Reason: {{reason}}. Text: {{text}}


Click button to see modal
open modal
Payment Confirmation
Confirm to pay $50.
Thankyou your payment recieved.
Google


{{averageRating > 0 ? averageRating : 0}} out of 5
Created on {{cur_lesson.created_at}}
Questions
{{$index+1}}
No search results found
This Lesson is not available.


--- title: Media - Medium, No Asset, Recently Published tags: object date: 2016/08/06 pattern_number: 1.3 ---


Algerians protest election plan, mark independence war
It was the 37th such gathering since their pro-democracy movement began in February.
Police are struggling to contain thousands of Algerian demonstrators surging through the streets of the capital, Algiers, to protest against plans for next month's presidential election and celebrate the 65th anniversary of the start of the country's war for independence from France.
Waving Algerian and banned Berber flags during Friday's rally, demonstrators urged each other to remain peaceful as police tried to push them off sidewalks or clear them out of a central square.
More:
It was the 37th such gathering since their pro-democracy movement began in February, and coincided with the anniversary of Algeria's war for liberation from French rule, which began on November 1, 1954.
Thousands of people came from other towns to join the protest in Algiers, some demonstrating peacefully in the streets overnight. In their homes, many residents banged on pots and pans to show support.
The visitors then rested with friends or family, or in their cars, and reconvened on Friday morning to march through the capital.
The protesters' anger focuses on the December 12 presidential election, to replace longtime leader Abdelaziz Bouteflika.
He was forced to step down in April after weeks of nationwide protests and amid pressure from the country's powerful military over his bid for a fifth term in office.
Protesters are demanding sweeping reforms in the oil-rich country before any fresh vote takes place, and say Bouteflika-era figures still in power must not use the presidential poll as an opportunity to appoint his successor.
"Dump the generals in the garbage!" shouted some demonstrators, referring notably to powerful army chief General Ahmed Gaid Salah. Gaid Salah helped push out the previous president, but demonstrators increasingly see him as part of the system they want to change.
The war anniversary drew larger-than-usual crowds to Friday's protest, where people repeatedly chanted "independence! independence!" One banner read: "Algeria was freed, and the people now struggle to free themselves."
Algeria's conflict with France lasted for six years and left scars on the countries' relations that remain to this day.


This course will address basic data visualization techniques and design principles. Students will use R with the ggplot2 and shiny packages to prototype visualizations. Students will obtain practical experience with the visualization of complex data, including multivariate data, geospatial data, textual data, time series, and network data.
I will be speaking at the Big Data Visualisation - South Bay meetup on Tuesday, May 13, 2014. My talk will be:
How Good People Make Bad Graphs: Unintentional Fibbing with Visualization
Reasonable goals can often result in incredibly misleading visualizations. This talk will show several examples illustrating how easy (and how dangerous) it is to lie with data visualization, and discuss some of the goals that may have led to that result. Then, we will explore how to rework those visualizations to still achieve those goals without distorting our perception of the data.
I will post slides here after the meetup.
I will hold bonus office hours this week on Tuesday 05/06 and Thursday 05/08 after class in the 5th floor lobby to help with any remaining bugs you have in your final projects. Also, please post on Piazza for help instead of sending me email. (This actually has a better chance of getting a response from me, since my email is flooded.)
The IEEE Conference on Visual Analytics Science and Technology (IEEE VAST) hosts a yearly visualization challenge. The challenges are open to participation by individuals and teams in industry, government, and academia.
All participants are invited to submit a two-page summary of their entry for inclusion in the IEEE VIS 2014 electronic conference proceedings, and attend the VAST Challenge 2014 Workshop, to be held in conjunction with IEEE VIS 2014 in Paris, France.
There are 3 mini challenges and 1 grand challenge. The data involved includes text (including streaming), network, geospatial, temporal, and transaction data. Visit http://vacommunity.org/VAST+Challenge+2014 for more details.
The submission deadline is July 8, 2014 at 11:59pm Pacific Daylight Time (UTC/GMT -9 hours).
You can find details about your final presentation, including the randomly generated presentation order, on the Instructure Canvas website.
Everyone will have 7 minutes total to present, including setup and questions. You will need to be prepared and practiced to give a strong short presentation!
The Data Visualization Speaker Series presents:
Monday, April 28, 2014
6:30pm to 9:00pm
McLaren, Room 250
Reza's talk will explore the process of designing and implementing interfaces and generative visualizations. He will showcase his most recent works and address the aesthetic considerations and challenges involved in creating each piece.
| Time | Description |
|---|---|
| 6:30 – 7:15 | Doors open, socializing, food, drinks |
| 7:15 – 8:15 | Speaker's presentation |
| 8:15 – 9:00 | More socializing, Q&A |
Bio: Reza is a computational designer and creative engineer. He uses code to express himself, and creates tools and libraries to help others create. He is the author of ofxUI, one of the most popular add-ons for openFrameworks (an arts-engineering toolkit). Though his works is highly visual, he is interested in the ideas and implications of his tools, works, and methodology. As an artist and engineer he is deeply interested in the feedback cycle that occurs when customs tools are written to accomplish an artwork, and how those tools can enable artworks to go beyond what the artist had originally envisioned. Reza is excited to find those happy accidents, beautiful moments of interaction and magic that comes with making something novel with technology. He hopes to change the world by making a difference in how people use technology, design products and experience new media art and entertainment.
Notice: Attendance at this event is mandatory, and will replace lecture on Tuesday 4/29. (We will not meet on Tuesday 4/29 as a result.)


Make a video file from a sequence of still images using FFmpeg.
ffmpeg(dir = ".", pattern, output, output_dir = ".", rate = "ntsc", delay = 1, start = 1, size = "source", preset = "ultrafast", codec = "default", format = "yuv420p", lossless = FALSE, min.rate = 10, fps.out = rate, alpha = 1, overwrite = FALSE, glob = FALSE, details = FALSE)
| dir | directory containing images, defaults to working directory. |
|---|---|
| pattern | character, for matching a set of input image files. See details for acceptable and possible alternative patterns. |
| output | character, output file name. |
| output_dir | character, output directory. Defaults to working directory. |
| rate | integer or character, intended framerate of input image sequence in Hertz (Hz) or frames per second (fps). See details. |
| delay | numeric, time delay between frames in output video. Alternative to |
| start | integer, frame to start from in input image sequence. Defaults to |
| size | character, the dimensions of the video output. Defaults to |
| preset | character, encoding presets available in FFmpeg. Defaults to |
| codec | character, the video codec used. See details. |
| format | character, the pixel format. See details. |
| lossless | logical, use lossless H.264 encoding if applicable. Defaults to |
| min.rate | integer, the minimum frame rate for non- |
| fps.out | integer or character, framerate of output video. This can be given in the same ways as |
| alpha | numeric, from 0 to 1.0. Only applicable when |
| overwrite | logical, overwrite existing output file. |
| glob | logical, defaults to |
| details | logical, whether to show FFmpeg output on the R console. |
returns the system call to FFmpeg as a character string.
ffmpeg
is a wrapper function around the popular FFmpeg command line multimedia framework.
It translates arguments provided by the user in familiar R syntax into a system call to the ffmpeg
command line tool, which must be installed on the system.
ffmpeg
does not provide complete flexibility to allow making every possible valid call to FFmpeg,
but users who are that well versed in the use of FFmpeg can use the command line utility directly or pass their custom calls directly to system
from within R.
The ffmpeg
R function is primarily useful to users not well versed in the use of the FFmpeg multimedia framework who will be satisfied with the level of flexibility provided.
Since this function is provided in the context of the mapmate
package, it is aimed at assisting with converting still image sequences to video.
While additional uses may be incorporated into ffmpeg
in future, the FFmpeg multimedia framework itself provides a far broader suite of tools and functionality than is needed here.
Keep in mind that the purpose of mapmate
is not to generate animations directly from R. See packages like animation
if that is more the goal.
The goal that mapmate
attempts to fulfill is strictly that of animation pre-production and it does so by focusing on the generation of still image sequences.
Any animation is expected to be done later by the user via software dedicated to video editing and production.
ffmpeg
is provided in mapmate
as an exception to the rule for users who wish to trade the full control and flexibility over video editing and production
that mapmate
aims to avoid entangling itself with for the convenience of generating relatively basic video output directly from an R session.
Ultimately, if you want an incredibly fancy video, do not rely on ffmpeg
to splice and merge and overlay and juxtapose all your layers together,
to crop and pan and rotate, to apply effects and transitions and every other form of video processing to your image sequences; finish the production outside of R, because that is what makes sense.
If you are an FFmpeg expert, you don't need to use ffmpeg
at all (but perhaps consider helping to improve this code!).
If you are not an FFmpeg expert, use other video editing software.
There always comes a point where it makes the most sense to transition from one application to another.
When external solutions exist, it does not make sense to port the solution to every problem into R.
Future package versions may provide more and more functionality and control over video production directly from R through ffmpeg
or other functions,
but at this time this should not be a primary development goal for mapmate
.
myimages%04d.png
,
which requires specifying the entire, non-changing file name with the only substitution being for the unique, order, consecutive integer file numbering component of the file name.
The pattern used indicates how may places are occupied by the file indices, which should be constant. In this example, %04d
represents the file numbering 0000, 0001, 0002, ..., 9999
.
If using Windows, you must use this approach. Any image sequences generated by mapmate
will follow this kind of file naming convention.
If you want to make videos from image sequences not made by mapmate
, they will also commonly follow this convention, but not always, in which case you will have to rename your files.
An alternative and often convenient way to provide a general pattern for matching to a set of input files is with globbing. However, globbing is not available on Windows.
Linux users may find this additional option helpful in cases where file naming is not quite as described above or, for example, if there are multiple sequences of files in one directory.
If glob=TRUE
, wildcards can be used in the pattern
argument, e.g., pattern="*png"
, pattern="myimages*png"
, or pattern="*images0*.png"
.
The default is glob=FALSE
and glob
is simply ignored on Windows.
The current package version of ffmpeg
allows merging more than two sequences without error,
but testing has not confirmed this is actually working correctly, as all layers do not always appear in the output video.
pattern
may be a vector referring to multiple image sequences. This is for merging or blending layers into one output video file.
The first vector element refers to the top layer among image sequences.
All files do not need to be in the same directory; dir
can be vectorized to match with pattern
if sequences are in different locations.
Similarly, rate
, delay
, and start
can be vectors. If nothing but pattern
is a vector, the other arguments are duplicated.
Vectors should be of equal length.
Merging capabilities are limited. An expert in the use of FFmpeg should use it directly and not via this wrapper function.
If merging sequences with this function, it is recommended they be the same number of frames, begin from the same starting frame, and proceed at the same frame rate, though this is not strictly required.
Also, merging only two sequences at a time is recommended or they may not all display.
Sequences must be very similar in a variety of respects. For example, images must be the same dimensions across sequences.
For greater control, use FFmpeg directly from the command line and consult official FFmpeg documentation, or help improve this wrapper function via Github issues and pull requests.
Remember that mapmate
generates still image sequences that are intended for later use in a dedicated video editing program, one with a GUI, unlike FFmpeg which is a command line application.
In such a program, it is assumed the user may be dropping multiple image sequences on different tracks of a project timeline, layering the tracks together,
and for this reason the default background png color is transparent.
In the default case, using alpha
less than 1.0
is generally unnecessary when merging two image sequences into a video with FFmpeg.
If not using defaults, alpha
may not provide the flexibility desired.
rate
, non-integer numeric values are rounded. Character options may be a valid abbreviation such as "ntsc"
or a quoted ratio such as "30000/1001"
.
Note that this is the familiar "29.97" (or, 29.97003, to be exact) but FFmpeg does not accept values like these.
Using delay
instead of rate
is more limiting since delay
is converted back to rate (\(delay=1/rate\)), but must then be rounded to an integer.
Using rate
is recommended. Arbitrary, non-standard framerates may lead to rendered videos that do not play properly in many media players.
For common settings and character abbreviations, see FFmpeg standard video rates.
rate
technically refers to the assumed or intended framerate of the input image file sequence.
This is important to mention because of the distinction between input and output framerates in FFmpeg.
See the details below on min.rate
and fps.out
to understand the differences and how to avoid some common problems.
size
is not set to "source"
, the output video is scaled.
size
can be a character string of dimensions in length by height format such as "720x480"
or an abbreviated standard such as "ntsc"
.
See FFmpeg standard video sizes for common dimensions and available abbreviations.
ultrafast
, superfast
, veryfast
, faster
, fast
, medium
, slow
, slower
, veryslow
.
Faster speed corresponds to greater file size. Slower speeds are due to greater compression.
codec
is ignored if the file name in pattern
ends with .gif
.
For other video output file types a default codec is used depending on the file extension in pattern
when codec="default"
.
These can be overridden with options like codec="h264"
, "libx264"
, "libvpx"
, "prores"
, "qtrle"
, etc.,
but the user needs to be knowledgeable regarding which codecs can be used for which output types or errors will be thrown.
format
is ignored if the file name in pattern
ends with .gif
.
The default is "yuv420p"
, which performs 4:2:0 chroma subsampling.
This pixel format can reduce video quality, but it is the default because it ensures compatibility with most media players, many of which still cannot play 4:4:4 video.
For valid alternatives, run system("ffmpeg -pix_fmts")
.
lossless
is ignored except for relevant codec
settings, e.g., h264
or libx264
.
If TRUE
, recommended preset
values are ultrafast
or veryslow
. See https://trac.ffmpeg.org/wiki/Encode/H.264
for more information.
min.rate
applies only to non-gif
video output. Video files typically have framerates of 25 fps or 30 fps or higher.
In the case of creating gifs from an image file sequence, low framerates on the order of 10 fps or lower, even 1 fps, are often desired.
If such a low framerate is desired for video file output, many media players may not be able to play, or play properly, such a video file.
For example, the popular VLC media player can have difficulties with playback of video files created with a framerate of less than 10 fps, particularly with rates closer to 1.
min.rate
sets a lower bound on the framerate of the output file.
The intended frame rate given by rate
or derived from delay
, of the input image file sequence specified in pattern
,
is still preserved in the output playback. However, if rate
is less than min.rate
, the output file will achieve min.rate
fps by duplicating frames.
For example, if rate=1
and min.rate=10
, a sequence consisting of 60 images will be converted to a 10 fps video containing 600 frames and taking the intended 60 seconds to play.
The tradeoff for compatibility with various media players is increased video file size, but depending on the codec, should not increase file size linearly,
e.g., not likely a ten times increase for the given example.
Nevertheless, control is given to the user over the video output fps lower bound via min.rate
. Just know that too low a value can cause problems.
If rate
is greater than min.rate
, the output file framerate will match the specified rate
of the input image sequence.
This also may not be desired if rate
is an atypical number for video framerates.
This matching can be overridden by specifying fps.out
as something other than rate
.
# NOT RUN { data(borders) library(dplyr) n <- 90 borders <- map(1:n, ~mutate(borders, id = .x)) %>% bind_rows() args <- list(width=300, height=300, res=300, bg="black") save_seq(borders, id="id", n.frames=n, col="white", type="maplines", file="images", png.args=args) ffmpeg(pattern="images_%04d.png", output="video.mp4", rate=10) # }


UofT Course Info
Configure
(current)
Textbooks
About
Feedback
General
Highlight Detected Courses
Google Search Info Cards
Max Tooltips per Page
Blocked URL Keywords
Separate these by commas
ie. google.com, piazza.com
Tooltip
Enable Tooltips
Department Link
Department Website
Arts and Science Calendar
Example invalid custom select feedback
Description
Sessions
Instructors
Prerequisites and Exclusions
Breadths


Orléans marks the high point of my trip, in that it's the furthest point north. Also, I get to install a new tire, and a new luggage rack! And, I think I've reached peak tacos.
Angers to Samur
Coming out of Angers, I noticed that the sidewall of my rear tire was coming apart. I guess they meant it when they said “max PSI 50” - with all the weight I'm carrying, I had been routinely inflating it to 4 or even 4.5 bar, which is like 58 to 65 PSI. Anyway, I made it to a bike shop! In Samur, there was this huge music and food festival.
Samur to Tours
Tours
In Tours, I stayed with the wonderful Héléna, who works as a nurse. She has two awesome dogs. Tours is where I decided that France has reached peak tacos. You can get a tacos at KFC here, only one side of it is open. Weird! At another place, they have a 3 kg tacos (free if you eat all of it). I tells ya, France has reached peak tacos.
Tours to Blois
Orléans
Next, the high point of my trip, insofar as this is the furtherst north I go. Other than that, not so great. Leaving Tours, I noticed that my luggage rack had broken. I was able to cobble together a sort-of fix, but I had to stop a couple of times to re-do my fix. The truth is, normal bicycles just aren't meant to carry luggage. Bikes that are mean to carry luggage are specialized, and somewhat expensive. Anyway, with the rear wheel, the rear tire, and the luggage rack replaced with stronger units, I'm pretty sure I'll be OK the rest of the way.
Orléans is kind of a big city, and from where I was staying, the approach to the center was kind of ugly. I was also stressed from the not-yet-fixed luggage rack, admittedly. Coming at the town center from the direction of the train station the next day, it was actually quite pleasant.
Joan of Arc's house was destroyed in the bombing of 1940, and I think the city was basially flattened. In Gien, I found out who did the bombing – first the Germans, then (at least in the case of Gien), the French. Then, in 1944, we Americans bombed Orléans (and other parts of France).
Orléans to Gien
Gien
Gien is neat. It's a lovely little town along the river, and it's not super touristy or gentrified. Actually, it's in a bit of a decline – the population went from 17,000 a few years ago to about 14,000 now, due to some factory closings. The town was pretty much flattened in 1940, first by the German airforce, and then by French artillery shooting at the Germans. Around 1950 it was rebuilt.
Up next
Here's my next several stops, mapped out. The first two are Orléans and Gien. I've arranged accommodation in all these places – yay! Airbnb thinned out, and normal bed and breakfasts and hotels are more affordable, and more available along here, so I'll be doing more of that. Also, I get to meet my friend Céline's mother!


[1]
the room which was quite deep for the young infant and hence kind of not usable .
[2]
the management would be getting great results due to this man at the helm at jamavar .


In addition to the data part, messages carry information that can be used to distinguish messages and selectively receive them. This information consists of a fixed number of fields, which we collectively call the message envelope. These fields are
The message source is implicitly determined by the identity of the message sender. The other fields are specified by arguments in the send operation.
The message destination is specified by the dest argument.
The integer-valued message tag is specified by the tag argument. This integer can be used by the program to distinguish different types of messages. The range of valid tag values is , where the value of UB is implementation dependent. It can be found by querying the value of the attribute MPI_TAG_UB, as described in Chapter MPI Environmental Management . MPI requires that UB be no less than 32767.
The comm argument specifies the communicator that is used for the send operation. Communicators are explained in Chapter Groups, Contexts, Communicators, and Caching ; below is a brief summary of their usage.
A communicator specifies the communication context for a communication operation. Each communication context provides a separate ``communication universe'': messages are always received within the context they were sent, and messages sent in different contexts do not interfere.
The communicator also specifies the set of processes that share this communication context. This process group is ordered and processes are identified by their rank within this group. Thus, the range of valid values for dest is 0, ..., n-1 cup {constMPI_PROC_NULL}, where n is the number of processes in the group. (If the communicator is an inter-communicator, then destinations are identified by their rank in the remote group. See Chapter Groups, Contexts, Communicators, and Caching .)
A predefined communicator MPI_COMM_WORLD is provided by MPI. It allows communication with all processes that are accessible after MPI initialization and processes are identified by their rank in the group of MPI_COMM_WORLD.
Advice to users.
Users that are comfortable with the notion of a flat name space for processes, and a single communication context, as offered by most existing communication libraries, need only use the predefined variable MPI_COMM_WORLD as the comm argument. This will allow communication with all the processes available at initialization time.
Users may define new communicators, as explained in Chapter Groups, Contexts, Communicators, and Caching
.
Communicators provide an important encapsulation mechanism for libraries and
modules. They allow modules to have their own disjoint communication universe
and their own process numbering scheme.
( End of advice to users.)
Advice
to implementors.
The message envelope
would normally be encoded by a fixed-length message header.
However, the actual encoding
is implementation dependent. Some of the information (e.g.,
source or destination) may be implicit, and need not be
explicitly carried by messages. Also, processes may be identified by
relative ranks, or absolute ids, etc.
( End of advice to implementors.)


Sign In
Forgot your password?
or sign in with one of these services
Facebook
Google
Georgia Tech


How can there be no ginkgo in autumn?
It seems that ginkgo has turned yellow overnight，The yellow ginkgo leaves shine brightly in the sun, with a wisp of sunlight and gentle autumn wind between the leaves, both warm and comfortable.
秋天怎能没有银杏？
似乎一夜之间，银杏叶就已经黄了一大片。
银杏在阳光的照耀之下更加灿烂夺目，伴随着从树叶缝隙之间透过来的缕缕阳光和徐徐秋风，既温暖又舒适。
I used my cellphone HUAWEI NCE-AL00 for this photo.
This page is synchronized from the post: ‘Ginkgo’


| DOSE: |
repeated |
oral |
GHB |
(liquid) |
I first started taking GHB a few years ago, but only drank it on the nights I went out. It was really fun to use in clubs and I saw no side effects for a long time. I would also use it sometimes to put me asleep, I never had a sleep problem, but it was nice to use when I wanted to go to sleep early for a long night's rest. Then I saw myself taking it every night. I took about 8 caps one night (not all at once) and couldnít sleep, I was having bad withdrawals, my symptoms were jitters, stress, heart palputations, and a BAD case of insomnia. In fact, I went six days straight without sleep, until I got my hands on some valiums. The insomnia lasted about six weeks with the help of melatonins. Tylenol PMs would give me about 2 hours of sleep.
After about 2 weeks that the insomnia was gone, I took a little G and the insomnia came back, it lasted a month. But I still didnít learn my lesson, so I took a six month break from taking it, and got away with it for about 5 nights, this case was the longest, 2 months of taking sleeping pills, my doctor gave me tamazapans. They work well but my racquetball game sucked the whole time. I took another six months off of it and thought maybe I can get away with it once a week, the 3rd time I took it, back to the insomnia today. I know that this is called the dopamine rebound, and the brain gets flooded with dopamine causing no sleep. Therefore I donít think I can ever take it again and I would like to take some just occasionally.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Mutahi Ngunyi’s message to William Ruto – stop advising yourself
by Tony MukereNgunyi explains Ruto's tweets on Kibra
Renowned political analyst Prof Mutahi Ngunyi has advised Deputy President William Ruto on the need to broaden his base of advisors rather than running a one-man show.
Ngunyi said that Ruto’s pride as a self-made man was also his bane as he was essentially only accountable to himself.
The political analyst said such leaders who are self-made tend to run a one-man show that mutates into a dictatorship.
“William Ruto advises William Ruto. He is only accountable to himself. At least we know Uhuru Kenyatta has a mother and a wife who will tell him when he is off-track. Raila Odinga has Ida who actively advises him. I don’t foresee a situation where Rachael Ruto calls him and he is nyoroshwad (straightened) by his wife.”
“If you look at the people around him, they are all rented. He needs to look for a mentor around the region, maybe Museveni or Magufuli. That way, he can be accountable to certain people,” Ngunyi said.
The professor of political economy noted that Ruto’s bitter complain regarding the Kibra by-election was proof of poor mentorship noting that the DP was reacting out of irritation and Raila’s team was taking advantage.
“The art of war teaches that when your enemy is easily irritable, prod him and make him irritated at all times. That is what ODM is doing. They are prodding him like a frog and he jumps up with a tweet,” he said.


Popular Areas in harley davidson fort washin gton
Harley-Davidson of Washington, DC Motorcycle Dealer at 9407 ...
Harley-Davidson of Washington, DC is a Buell, Harley-Davidson motorcycle dealership located at 9407 Livingston Road, Fort Washington, MD.
http://www.motorcycle-usa.com/3349/Motorcycle-Dealer-Contact/Harley-Davidson-of-Washington--DC.aspx
Fort Washington HOG Chapter
Fort Washington Maryland Chapter Harley Owners Group Chapter #0628 - Chartered 1988 . Visit our Chapter sponsor Harley-Davidson of Washington DC .
http://www.hdwashhog.com/
Harley-Davidson Dealer Washington DC: New, Used Motorcycles ...
Harley-Davidson of Washington D.C. is your one stop shop for everything . Harley-Davidson of Washington, D.C. in Fort Washington, MD carries new Harley - .
http://www.hdwash.com/
Map/Hours - Harley-Davidson of Washington
Harley-Davidson dealership in Fort Washington, Maryland. We serve the greater Washington DC metro of Maryland and Northern Virginia. Stop on in to see the .
http://www.hdwash.com/map_hours.asp
Pre Owned Inventory - Harley-Davidson of Washington
We have a great selection of used Harley-Davidson® .
http://www.hdwash.com/pre_owned_list.asp
Ft. Washington Harley Davidson - Motorcycles | Facebook
Harley-Davidson of Washington, DC is located in Fort Washington, MD-just outside of Washington, DC. We have the largest selection of Motorcycles, Genuine .
http://www.facebook.com/pages/Ft-Washington-Harley-Davidson/204890562882691
Harley davidson in Fort Washington, MD | Fort ... - Yellowpages.com
Results 1 - 30 of 40 . 40 listings of Motorcycle Dealers in Fort Washington on YP.com. Find reviews, directions & phone numbers for the best harley davidson in .
http://www.yellowpages.com/fort-washington-md/harley-davidson


Heliotrope tucks Collector's Retreat into lush wooded site in coastal Washington
by Jenna McKnightAmerican studio Heliotrope Architects has created a holiday home for art gallery owners that is wrapped in dark metal, punctured with white stucco and large stretches of glass.
Collector's Retreat is located on a forested site on Orcas Island, which lies just off the coast of northern Washington. It serves as a second home for a couple who own a Los Angeles gallery that features the work of West Coast artists.
For their getaway retreat, the clients wanted a cabin that offered both expansive views and space for artwork. They turned to Heliotrope Architects, a firm with offices in Seattle and Portland.
"They desired a retreat with the feel of a contemporary art gallery, with plenty of wall space to display a rotation of their collection while also capturing expansive views offered by the site," the studio said.
Envisioned as a "simple box,", the residence totals 1,600 square feet (149 square metres). The single-storey dwelling encompasses a living area and two bedrooms, along with a covered carport adjoined to a studio/utility room.
Exterior walls are wrapped in black metal panels and white stucco. Windows are framed in black-painted wood to help minimise their visual impact.
Inside, the team used grey concrete and light-toned finishes such as Carrera marble. A need to be cost-effective informed the architect's selection of materials – and their design overall.
"A tight budget was managed through efficient design, simple detailing and a liberal use of IKEA cabinetry," the studio said.
Inside, the dwelling contains an open-plan public area and two bedroom suites – one for the couple, and one for their grown daughter. Floor-to-ceiling glass provides sweeping vistas of the lush, wooded landscape.
"The main living space is flanked on either side by the bedroom suites, focusing views in an axial manner toward the water and the wetland forest," the studio said.
Rooms are adorned with streamlined furnishings and contemporary artwork. In the great room, glazed doors open onto a concrete terrace with a fit pit, which "serves as the primary focus for summer leisure."
Collector's Retreat is situated within the San Juan Islands, an archipelago in Washington State that is near Seattle and British Columbia. Other projects there include the False Bay House by Olson Kundig, which features pivoting doors and sliding shutters, and the Hillside Sanctuary by Hoedemaker Pfeiffer, which is perched on an elevated site overlooking the water.
Photography is by Sean Airhart.
Project credits:
Architect: Heliotrope Architects
Contractor: The Green Construction Company


Qref prides ourselves on top-notch customer service. To prove it, we've set up a special phone line and email for you to talk to someone if you need help with this app and can't find your answer below.
(682) 422-7733
Hours: Monday through Saturday, 9am - 6pm Central Time
No problem. Qref checklists are but a tap away. Purchase and download the checklist you need directly from the app. Tap Download to view a list of available aircraft models. This list is being added to regularly, so check back if you don't see the checklist you need.
Absolutely! Press the pencil icon at the top of the page to turn on/off edit mode.
Set up a Qref account to back up your changes and keep track of your checklist purchases.
On the dashboard, press the pencil icon at the top of the page to turn on edit mode. Tap on the desired aircraft and you will be prompted for the tail number.
The tail number will be synced with your account the next time you log in or select Manual Sync from the menu. This means you'll see the tail number (and any checklist edits) on any device you log in with using the Qref app.


Toggle navigation
World JS: Evolution Simulator
Home
Github
Close
Statistic
Basic
More
•
Men:
0
•
Women:
0
•
Boys:
0
•
Girls:
0
•
Families:
0
• Average children
per family:
0
• Food resource:
0
!
•
0
% food resource per year
•
/
Adult:
0
food per year
•
/
Child:
0
food per year
• Death rate:
0
%
• Average age:
0
• Max age:
0
(died in
0
)
• Average IQ:
0
• Max IQ:
0
(born in
0
)
• Food spoilage:
-
0
% food per year
Year
0
Freeze
0
0
0
0
0
...
Population
Limit
0
Food
Famine
0
Total IQ
0
Knowledge
Trending
History


class SparseMatrixD extends MatriD with Error with Serializable
The SparseMatrixD
class stores and operates on Matrices of Doubles. Rather
than storing the matrix as a 2 dimensional array, it is stored as an array
of sorted-linked-maps, which record all the non-zero values for each particular
row, along with their j-index as (j, v) pairs.
Note: _npp versions of methods are not appropriate for sparse matrices
(i.e., always use partial pivoting).
- Alphabetic
- By Inheritance
- SparseMatrixD
- Serializable
- Serializable
- MatriD
- Error
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
SparseMatrixD(u: MatrixD)
Construct a sparse matrix and assign values from (MatrixD) matrix u.
Construct a sparse matrix and assign values from (MatrixD) matrix u.
- u
the matrix of values to assign
-
new
SparseMatrixD(u: SparseMatrixD)
Construct a sparse matrix and assign values from matrix u.
Construct a sparse matrix and assign values from matrix u.
- u
the matrix of values to assign
-
new
SparseMatrixD(dim1: Int, x: Double)
Construct a dim1 by dim1 square sparse matrix with x assigned on the diagonal and 0 assigned off the diagonal.
Construct a dim1 by dim1 square sparse matrix with x assigned on the diagonal and 0 assigned off the diagonal. To obtain an identity matrix, let x = 1.
- dim1
the row and column dimension
- x
the scalar value to assign on the diagonal
-
new
SparseMatrixD(dim1: Int, dim2: Int, x: Double)
Construct a dim1 by dim2 sparse matrix and assign each element the value x.
Construct a dim1 by dim2 sparse matrix and assign each element the value x.
- dim1
the row dimension
- dim2
the column dimesion
- x
the scalar value to assign
-
new
SparseMatrixD(dim1: Int)
Construct a dim1 by dim1 square sparse matrix.
Construct a dim1 by dim1 square sparse matrix.
- dim1
the row and column dimension
-
new
SparseMatrixD(dim1: Int, dim2: Int, u: Array[SortedLinkedHashMap[Int, Double]])
Construct a dim1 by dim2 sparse matrix from an array of sorted-linked-maps.
Construct a dim1 by dim2 sparse matrix from an array of sorted-linked-maps.
- dim1
the row dimension
- dim2
the column dimension
- u
the array of sorted-linked-maps
-
new
SparseMatrixD(d1: Int, d2: Int)
- d1
the first/row dimension
- d2
the second/column dimension
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
*(x: Double): SparseMatrixD
Multiply this sparse matrix by scalar x.
Multiply this sparse matrix by scalar x.
- x
the scalar to multiply by
- Definition Classes
- SparseMatrixD → MatriD
-
def
*(u: VectoD): VectorD
Multiply this sparse matrix by vector u.
Multiply this sparse matrix by vector u.
- u
the vector to multiply by
- Definition Classes
- SparseMatrixD → MatriD
-
def
*(b: MatriD): SparseMatrixD
Multiply this sparse matrix by matrix b.
Multiply this sparse matrix by matrix b.
- b
the matrix to multiply by (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
*(b: SparseMatrixD): SparseMatrixD
Multiply this sparse matrix by sparse matrix b, by performing a merge operation on the rows on this sparse matrix and the transpose of the b matrix.
Multiply this sparse matrix by sparse matrix b, by performing a merge operation on the rows on this sparse matrix and the transpose of the b matrix.
- b
the matrix to multiply by (requires sameCrossDimensions)
-
def
**(u: VectoD): SparseMatrixD
Multiply this sparse matrix by vector u to produce another matrix (a_ij * u_j)
Multiply this sparse matrix by vector u to produce another matrix (a_ij * u_j)
- u
the vector to multiply by
- Definition Classes
- SparseMatrixD → MatriD
-
def
**=(u: VectoD): SparseMatrixD
Multiply in-place this sparse matrix by vector u to produce another matrix (a_ij * u_j)
Multiply in-place this sparse matrix by vector u to produce another matrix (a_ij * u_j)
- u
the vector to multiply by
- Definition Classes
- SparseMatrixD → MatriD
-
def
*:(u: VectoD): VectoD
Multiply (row) vector 'u' by 'this' matrix.
Multiply (row) vector 'u' by 'this' matrix. Note '*:' is right associative. vector = vector *: matrix
- u
the vector to multiply by
- Definition Classes
- MatriD
-
def
*=(x: Double): SparseMatrixD
Multiply in-place this sparse matrix by scalar x.
Multiply in-place this sparse matrix by scalar x.
- x
the scalar to multiply by
- Definition Classes
- SparseMatrixD → MatriD
-
def
*=(b: MatriD): SparseMatrixD
Multiply in-place this sparse matrix by matrix b.
Multiply in-place this sparse matrix by matrix b.
- b
the matrix to multiply by (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
*=(b: SparseMatrixD): SparseMatrixD
Multiply in-place this sparse matrix by sparse matrix b, by performing a merge operation on the rows on this sparse matrix and the transpose of the b matrix.
Multiply in-place this sparse matrix by sparse matrix b, by performing a merge operation on the rows on this sparse matrix and the transpose of the b matrix.
- b
the matrix to multiply by (requires square and sameCrossDimensions)
-
def
+(x: Double): MatrixD
Add this sparse matrix and scalar x.
Add this sparse matrix and scalar x. Note: every element will be likely filled, hence the return type is a dense matrix.
- x
the scalar to add
- Definition Classes
- SparseMatrixD → MatriD
-
def
+(b: MatriD): SparseMatrixD
Add 'this' sparse matrix and matrix 'b'.
Add 'this' sparse matrix and matrix 'b'. 'b' may be any subtype of
MatriD
.- b
the matrix to add (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
+(b: MatrixD): SparseMatrixD
Add 'this' sparse matrix and matrix 'b'.
Add 'this' sparse matrix and matrix 'b'. FIX: if same speed as method below - remove
- b
the matrix to add (requires sameCrossDimensions)
-
def
+(u: VectoD): SparseMatrixD
Add this matrix and (row) vector u.
-
def
+(b: SparseMatrixD): SparseMatrixD
Add 'this' sparse matrix and sparse matrix 'b'.
Add 'this' sparse matrix and sparse matrix 'b'.
- b
the matrix to add (requires sameCrossDimensions)
-
def
++(b: MatriD): SparseMatrixD
Concatenate (row-wise) 'this' matrix and matrix 'b'.
Concatenate (row-wise) 'this' matrix and matrix 'b'.
- b
the matrix to be concatenated as the new last rows in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
def
++^(b: MatriD): SparseMatrixD
Concatenate (column-wise) 'this' matrix and matrix 'b'.
Concatenate (column-wise) 'this' matrix and matrix 'b'.
- b
the matrix to be concatenated as the new last columns in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
def
+:(u: VectoD): SparseMatrixD
Concatenate (row) vector 'u' and 'this' matrix, i.e., prepend 'u' to 'this'.
Concatenate (row) vector 'u' and 'this' matrix, i.e., prepend 'u' to 'this'.
- u
the vector to be prepended as the new first row in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
def
+=(x: Double): SparseMatrixD
Add in-place this sparse matrix and scalar x.
Add in-place this sparse matrix and scalar x.
- x
the scalar to add
- Definition Classes
- SparseMatrixD → MatriD
-
def
+=(u: VectoD): SparseMatrixD
Add in-place this matrix and (row) vector u.
Add in-place this matrix and (row) vector u.
- u
the vector to add
- Definition Classes
- SparseMatrixD → MatriD
-
def
+=(b: MatriD): SparseMatrixD
Add in-place this sparse matrix and matrix b.
Add in-place this sparse matrix and matrix b.
- b
the matrix to add (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
+=(b: SparseMatrixD): SparseMatrixD
Add in-place this sparse matrix and sparse matrix b.
Add in-place this sparse matrix and sparse matrix b.
- b
the matrix to add (requires sameCrossDimensions)
-
def
+^:(u: VectoD): SparseMatrixD
Concatenate (column) vector 'u' and 'this' matrix, i.e., prepend 'u' to 'this'.
Concatenate (column) vector 'u' and 'this' matrix, i.e., prepend 'u' to 'this'.
- u
the vector to be prepended as the new first column in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
def
-(x: Double): MatrixD
From this sparse matrix subtract scalar x.
From this sparse matrix subtract scalar x. Note: every element will be likely filled, hence the return type is a dense matrix.
- x
the scalar to subtract
- Definition Classes
- SparseMatrixD → MatriD
-
def
-(u: VectoD): SparseMatrixD
From this matrix subtract (row) vector u.
From this matrix subtract (row) vector u.
- u
the vector to subtract
- Definition Classes
- SparseMatrixD → MatriD
-
def
-(b: MatriD): SparseMatrixD
From this sparse matrix substract matrix b.
From this sparse matrix substract matrix b.
- b
the matrix to subtract (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
-(b: SparseMatrixD): SparseMatrixD
From this sparse matrix substract matrix b.
From this sparse matrix substract matrix b.
- b
the sparse matrix to subtract (requires sameCrossDimensions)
-
def
-=(x: Double): SparseMatrixD
From this sparse matrix subtract in-place scalar x.
From this sparse matrix subtract in-place scalar x.
- x
the scalar to subtract
- Definition Classes
- SparseMatrixD → MatriD
-
def
-=(u: VectoD): SparseMatrixD
From this matrix subtract in-place (row) vector u.
From this matrix subtract in-place (row) vector u.
- u
the vector to subtract
- Definition Classes
- SparseMatrixD → MatriD
-
def
-=(b: MatriD): SparseMatrixD
From this sparse matrix substract in-place matrix b.
From this sparse matrix substract in-place matrix b.
- b
the matrix to subtract (requires sameCrossDimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
-=(b: SparseMatrixD): SparseMatrixD
From this sparse matrix substract in-place sparse matrix b.
From this sparse matrix substract in-place sparse matrix b.
- b
the sparse matrix to subtract (requires sameCrossDimensions)
-
def
/(x: Double): SparseMatrixD
Divide this sparse matrix by scalar x.
Divide this sparse matrix by scalar x.
- x
the scalar to divide by
- Definition Classes
- SparseMatrixD → MatriD
-
def
/=(x: Double): SparseMatrixD
Divide in-place this sparse matrix by scalar x.
Divide in-place this sparse matrix by scalar x.
- x
the scalar to divide by
- Definition Classes
- SparseMatrixD → MatriD
-
def
:+(u: VectoD): SparseMatrixD
Concatenate 'this' matrix and (row) vector 'u', i.e., append 'u' to 'this'.
Concatenate 'this' matrix and (row) vector 'u', i.e., append 'u' to 'this'.
- u
the vector to be appended as the new last row in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
def
:^+(u: VectoD): SparseMatrixD
Concatenate 'this' matrix and (column) vector 'u', i.e., append 'u' to 'this'.
Concatenate 'this' matrix and (column) vector 'u', i.e., append 'u' to 'this'.
- u
the vector to be appended as the new last column in new matrix
- Definition Classes
- SparseMatrixD → MatriD
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
apply(ir: Range, jr: Range): SparseMatrixD
Get a slice this matrix row-wise on range ir and column-wise on range jr.
Get a slice this matrix row-wise on range ir and column-wise on range jr. Ex: b = a(2..4, 3..5)
- ir
the row range
- jr
the column range
- Definition Classes
- SparseMatrixD → MatriD
-
def
apply(i: Int): VectorD
Get this sparse matrix's vector at the i-th index position (i-th row).
Get this sparse matrix's vector at the i-th index position (i-th row).
- i
the row index
- Definition Classes
- SparseMatrixD → MatriD
-
def
apply(i: Int, j: Int): Double
Get this sparse matrix's element at the i,j-th index position.
Get this sparse matrix's element at the i,j-th index position.
- i
the row index
- j
the column index
- Definition Classes
- SparseMatrixD → MatriD
-
def
apply(i: Int, jr: Range): VectoD
Get a slice 'this' matrix row-wise at index 'i' and column-wise on range 'jr'.
Get a slice 'this' matrix row-wise at index 'i' and column-wise on range 'jr'. Ex: u = a(2, 3..5)
- i
the row index
- jr
the column range
- Definition Classes
- MatriD
-
def
apply(ir: Range, j: Int): VectoD
Get a slice 'this' matrix row-wise on range 'ir' and column-wise at index j.
Get a slice 'this' matrix row-wise on range 'ir' and column-wise at index j. Ex: u = a(2..4, 3)
- ir
the row range
- j
the column index
- Definition Classes
- MatriD
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bsolve(y: VectoD): VectorD
Solve for 'x' using back substitution in the equation 'u*x = y' where 'this' matrix ('u') is upper triangular (see 'lud' above).
Solve for 'x' using back substitution in the equation 'u*x = y' where 'this' matrix ('u') is upper triangular (see 'lud' above).
- y
the constant vector
- Definition Classes
- SparseMatrixD → MatriD
-
def
clean(thres: Double, relative: Boolean = true): SparseMatrixD
Clean values in matrix at or below the threshold by setting them to zero.
Clean values in matrix at or below the threshold by setting them to zero. Iterative algorithms give approximate values and if very close to zero, may throw off other calculations, e.g., in computing eigenvectors.
- thres
the cutoff threshold (a small value)
- relative
whether to use relative or absolute cutoff
- Definition Classes
- SparseMatrixD → MatriD
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
col(col: Int, from: Int = 0): VectorD
Get column 'col' from the matrix, returning it as a vector.
Get column 'col' from the matrix, returning it as a vector.
- col
the column to extract from the matrix
- from
the position to start extracting from
- Definition Classes
- SparseMatrixD → MatriD
-
def
copy(): MatriD
Create an exact copy of 'this' m-by-n matrix.
Create an exact copy of 'this' m-by-n matrix.
- Definition Classes
- SparseMatrixD → MatriD
- val d1: Int
- val d2: Int
-
def
det: Double
Compute the determinant of this sparse matrix.
Compute the determinant of this sparse matrix.
- Definition Classes
- SparseMatrixD → MatriD
-
def
diag(p: Int, q: Int): SparseMatrixD
Form a matrix [Ip, this, Iq] where Ir is a r by r identity matrix, by positioning the three matrices Ip, this and Iq along the diagonal.
Form a matrix [Ip, this, Iq] where Ir is a r by r identity matrix, by positioning the three matrices Ip, this and Iq along the diagonal.
- p
the size of identity matrix Ip
- q
the size of identity matrix Iq
- Definition Classes
- SparseMatrixD → MatriD
-
def
diag(b: MatriD): SparseMatrixD
Combine this sparse matrix with matrix b, placing them along the diagonal and filling in the bottom left and top right regions with zeros; [this, b].
Combine this sparse matrix with matrix b, placing them along the diagonal and filling in the bottom left and top right regions with zeros; [this, b].
- b
the matrix to combine with this matrix
- Definition Classes
- SparseMatrixD → MatriD
-
lazy val
dim1: Int
Dimension 1
Dimension 1
- Definition Classes
- SparseMatrixD → MatriD
-
lazy val
dim2: Int
Dimension 2
Dimension 2
- Definition Classes
- SparseMatrixD → MatriD
-
def
dot(u: VectoD): VectorD
Compute the dot product of 'this' matrix and vector 'u', by first transposing 'this' matrix and then multiplying by 'u' (ie., 'a dot u = a.t * u').
Compute the dot product of 'this' matrix and vector 'u', by first transposing 'this' matrix and then multiplying by 'u' (ie., 'a dot u = a.t * u').
- u
the vector to multiply by (requires same first dimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
dot(b: MatriD): VectoD
Compute the dot product of 'this' matrix and matrix 'b' that results in a vector, by taking the dot product for each column 'j' of both matrices.
Compute the dot product of 'this' matrix and matrix 'b' that results in a vector, by taking the dot product for each column 'j' of both matrices.
- b
the matrix to multiply by (requires same first dimensions)
- Definition Classes
- SparseMatrixD → MatriD
- See also
www.mathworks.com/help/matlab/ref/dot.html
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
val
fString: String
Format string used for printing vector values (change using 'setFormat')
Format string used for printing vector values (change using 'setFormat')
- Attributes
- protected
- Definition Classes
- MatriD
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
flaw(method: String, message: String): Unit
Show the flaw by printing the error message.
Show the flaw by printing the error message.
- method
the method where the error occurred
- message
the error message
- Definition Classes
- Error
-
def
foreach[U](f: (Array[Double]) ⇒ U): Unit
Iterate over 'this' matrix row by row applying method 'f'.
Iterate over 'this' matrix row by row applying method 'f'.
- f
the function to apply
- Definition Classes
- MatriD
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
getDiag(k: Int = 0): VectorD
Get the kth diagonal of this matrix.
Get the kth diagonal of this matrix. Assumes dim2 >= dim1.
- k
how far above the main diagonal, e.g., (-1, 0, 1) for (sub, main, super)
- Definition Classes
- SparseMatrixD → MatriD
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
inverse: SparseMatrixD
Invert this sparse matrix (requires a squareMatrix) using partial pivoting.
Invert this sparse matrix (requires a squareMatrix) using partial pivoting.
- Definition Classes
- SparseMatrixD → MatriD
-
def
inverse_ip(): SparseMatrixD
Invert in-place this sparse matrix (requires a squareMatrix).
Invert in-place this sparse matrix (requires a squareMatrix). This version uses partial pivoting.
- Definition Classes
- SparseMatrixD → MatriD
-
def
inverse_npp: SparseMatrixD
Invert this sparse matrix (requires a squareMatrix) not using partial pivoting.
-
def
isBidiagonal: Boolean
Check whether 'this' matrix is bidiagonal (has non-zero elements only in main diagonal and super-diagonal).
Check whether 'this' matrix is bidiagonal (has non-zero elements only in main diagonal and super-diagonal). The method may be overriding for efficiency.
- Definition Classes
- MatriD
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isNonnegative: Boolean
Check whether this sparse matrix is nonnegative (has no negative elements).
Check whether this sparse matrix is nonnegative (has no negative elements).
- Definition Classes
- SparseMatrixD → MatriD
-
def
isRectangular: Boolean
Check whether this sparse matrix is rectangular (all rows have the same number of columns).
Check whether this sparse matrix is rectangular (all rows have the same number of columns).
- Definition Classes
- SparseMatrixD → MatriD
-
def
isSquare: Boolean
Check whether 'this' matrix is square (same row and column dimensions).
Check whether 'this' matrix is square (same row and column dimensions).
- Definition Classes
- MatriD
-
def
isSymmetric: Boolean
Check whether 'this' matrix is symmetric.
Check whether 'this' matrix is symmetric.
- Definition Classes
- MatriD
-
def
isTridiagonal: Boolean
Check whether 'this' matrix is bidiagonal (has non-zero elements only in main diagonal and super-diagonal).
Check whether 'this' matrix is bidiagonal (has non-zero elements only in main diagonal and super-diagonal). The method may be overriding for efficiency.
- Definition Classes
- MatriD
-
def
leDimensions(b: MatriD): Boolean
Check whether 'this' matrix dimensions are less than or equal to 'le' those of the other matrix 'b'.
Check whether 'this' matrix dimensions are less than or equal to 'le' those of the other matrix 'b'.
- b
the other matrix
- Definition Classes
- MatriD
-
def
lowerT: MatriD
Return the lower triangular of 'this' matrix (rest are zero).
Return the lower triangular of 'this' matrix (rest are zero).
- Definition Classes
- SparseMatrixD → MatriD
-
def
lud: (SparseMatrixD, SparseMatrixD)
Decompose this sparse matrix into the product of lower and upper triangular matrices (l, u) using the LU Decomposition algorithm.
Decompose this sparse matrix into the product of lower and upper triangular matrices (l, u) using the LU Decomposition algorithm. This version uses partial pivoting.
- Definition Classes
- SparseMatrixD → MatriD
-
def
lud_ip(): (SparseMatrixD, SparseMatrixD)
Decompose in-place this sparse matrix into the product of lower and upper triangular matrices (l, u) using the LU Decomposition algorithm.
Decompose in-place this sparse matrix into the product of lower and upper triangular matrices (l, u) using the LU Decomposition algorithm. This version uses partial pivoting.
- Definition Classes
- SparseMatrixD → MatriD
-
def
mag: Double
Find the magnitude of 'this' matrix, the element value farthest from zero.
Find the magnitude of 'this' matrix, the element value farthest from zero.
- Definition Classes
- MatriD
-
def
max(e: Int = dim1): Double
Find the maximum element in this sparse matrix.
Find the maximum element in this sparse matrix.
- e
the ending row index (exclusive) for the search
- Definition Classes
- SparseMatrixD → MatriD
-
def
mdot(b: MatriD): MatriD
Compute the matrix dot product of 'this' matrix and matrix 'b', by first transposing 'this' matrix and then multiplying by 'b' (i.e., 'a dot b = a.t * b').
Compute the matrix dot product of 'this' matrix and matrix 'b', by first transposing 'this' matrix and then multiplying by 'b' (i.e., 'a dot b = a.t * b').
- b
the matrix to multiply by (requires same first dimensions)
- Definition Classes
- SparseMatrixD → MatriD
-
def
mean: VectoD
Compute the column means of this matrix.
Compute the column means of this matrix.
- Definition Classes
- MatriD
-
def
min(e: Int = dim1): Double
Find the minimum element in this sparse matrix.
Find the minimum element in this sparse matrix.
- e
the ending row index (exclusive) for the search
- Definition Classes
- SparseMatrixD → MatriD
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
norm1: Double
Compute the 1-norm of 'this' matrix, i.e., the maximum 1-norm of the column vectors.
Compute the 1-norm of 'this' matrix, i.e., the maximum 1-norm of the column vectors. This is useful for comparing matrices '(a - b).norm1'.
- Definition Classes
- MatriD
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
nullspace: VectorD
Compute the (right) nullspace of this m by n matrix (requires n = m + 1) by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1.
Compute the (right) nullspace of this m by n matrix (requires n = m + 1) by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1. The nullspace of matrix a is "this vector v times any scalar s", i.e., a*(v*s) = 0. The left nullspace of matrix a is the same as the right nullspace of a.t (a transpose).
- Definition Classes
- SparseMatrixD → MatriD
-
def
nullspace_ip(): VectorD
Compute the (right) nullspace in-place of this m by n matrix (requires n = m + 1) by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1.
Compute the (right) nullspace in-place of this m by n matrix (requires n = m + 1) by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1. The nullspace of matrix a is "this vector v times any scalar s", i.e., a*(v*s) = 0. The left nullspace of matrix a is the same as the right nullspace of a.t (a transpose).
- Definition Classes
- SparseMatrixD → MatriD
-
val
range1: Range
Range for the storage array on dimension 1 (rows)
Range for the storage array on dimension 1 (rows)
- Definition Classes
- MatriD
-
val
range2: Range
Range for the storage array on dimension 2 (columns)
Range for the storage array on dimension 2 (columns)
- Definition Classes
- MatriD
-
def
rank(upper: Boolean = false): Int
Determine the rank of 'this' m-by-n matrix by taking the upper triangular matrix 'u' from the 'LU' Decomposition and counting the number of non-zero diagonal elements.
Determine the rank of 'this' m-by-n matrix by taking the upper triangular matrix 'u' from the 'LU' Decomposition and counting the number of non-zero diagonal elements. Implementing classes may override this method with a better one (e.g., using 'SVD' or Rank Revealing 'QR').
- upper
flag indicating whether this matrix is already upper triangular
- Definition Classes
- MatriD
- See also
http://en.wikipedia.org/wiki/Rank_%28linear_algebra%29
-
def
reduce: SparseMatrixD
Use Guass-Jordan reduction on this sparse matrix to make the left part embed an identity matrix.
Use Guass-Jordan reduction on this sparse matrix to make the left part embed an identity matrix. A constraint on this m by n matrix is that n >= m.
- Definition Classes
- SparseMatrixD → MatriD
-
def
reduce_ip(): Unit
Use Guass-Jordan reduction in-place on this sparse matrix to make the left part embed an identity matrix.
Use Guass-Jordan reduction in-place on this sparse matrix to make the left part embed an identity matrix. A constraint on this m by n matrix is that n >= m.
- Definition Classes
- SparseMatrixD → MatriD
-
def
sameCrossDimensions(b: MatriD): Boolean
Check whether 'this' matrix and the other matrix 'b' have the same cross dimensions.
Check whether 'this' matrix and the other matrix 'b' have the same cross dimensions.
- b
the other matrix
- Definition Classes
- MatriD
-
def
sameDimensions(b: MatriD): Boolean
Check whether 'this' matrix and the other matrix 'b' have the same dimensions.
Check whether 'this' matrix and the other matrix 'b' have the same dimensions.
- b
the other matrix
- Definition Classes
- MatriD
-
def
selectCols(colIndex: Array[Int]): SparseMatrixD
Select columns from this matrix according to the given index/basis.
Select columns from this matrix according to the given index/basis. Ex: Can be used to divide a matrix into a basis and a non-basis.
- colIndex
the column index positions (e.g., (0, 2, 5))
- Definition Classes
- SparseMatrixD → MatriD
-
def
selectRows(rowIndex: Array[Int]): SparseMatrixD
Select rows from this matrix according to the given index/basis.
Select rows from this matrix according to the given index/basis.
- rowIndex
the row index positions (e.g., (0, 2, 5))
- Definition Classes
- SparseMatrixD → MatriD
-
def
set(i: Int, u: VectoD, j: Int = 0): Unit
Set this matrix's ith row starting at column j to the vector u.
Set this matrix's ith row starting at column j to the vector u.
- i
the row index
- u
the vector value to assign
- j
the starting column index
- Definition Classes
- SparseMatrixD → MatriD
-
def
set(u: Array[Array[Double]]): Unit
Set all the values in this matrix as copies of the values in 2D array u.
Set all the values in this matrix as copies of the values in 2D array u.
- u
the 2D array of values to assign
- Definition Classes
- SparseMatrixD → MatriD
-
def
set(x: Double): Unit
Set all the elements in this matrix to the scalar x.
Set all the elements in this matrix to the scalar x.
- x
the scalar value to assign
- Definition Classes
- SparseMatrixD → MatriD
-
def
setCol(col: Int, u: VectoD): Unit
Set column 'col' of the matrix to a vector.
Set column 'col' of the matrix to a vector.
- col
the column to set
- u
the vector to assign to the column
- Definition Classes
- SparseMatrixD → MatriD
-
def
setDiag(x: Double): Unit
Set the main diagonal of this matrix to the scalar x.
Set the main diagonal of this matrix to the scalar x. Assumes dim2 >= dim1.
- x
the scalar to set the diagonal to
- Definition Classes
- SparseMatrixD → MatriD
-
def
setDiag(u: VectoD, k: Int = 0): Unit
Set the kth diagonal of this matrix to the vector u.
Set the kth diagonal of this matrix to the vector u. Assumes dim2 >= dim1.
- u
the vector to set the diagonal to
- k
how far above the main diagonal, e.g., (-1, 0, 1) for (sub, main, super)
- Definition Classes
- SparseMatrixD → MatriD
-
def
setFormat(newFormat: String): Unit
Set the format to the 'newFormat'.
-
def
showAll(): Unit
Show all elements in this sparse matrix.
-
def
slice(r_from: Int, r_end: Int, c_from: Int, c_end: Int): SparseMatrixD
Slice this sparse matrix row-wise r_from to r_end and column-wise c_from to c_end.
Slice this sparse matrix row-wise r_from to r_end and column-wise c_from to c_end.
- r_from
the start of the row slice
- r_end
the end of the row slice
- c_from
the start of the column slice
- c_end
the end of the column slice
- Definition Classes
- SparseMatrixD → MatriD
-
def
slice(from: Int, end: Int): SparseMatrixD
Slice this sparse matrix row-wise from to end.
Slice this sparse matrix row-wise from to end.
- from
the start row of the slice
- end
the end row of the slice
- Definition Classes
- SparseMatrixD → MatriD
-
def
sliceCol(from: Int, end: Int): SparseMatrixD
Slice this sparse matrix column-wise 'from' to 'end'.
Slice this sparse matrix column-wise 'from' to 'end'.
- from
the start column of the slice (inclusive)
- end
the end column of the slice (exclusive)
- Definition Classes
- SparseMatrixD → MatriD
-
def
sliceExclude(row: Int, col: Int): SparseMatrixD
Slice this sparse matrix excluding the given row and column.
Slice this sparse matrix excluding the given row and column.
- row
the row to exclude
- col
the column to exclude
- Definition Classes
- SparseMatrixD → MatriD
-
def
solve(b: VectoD): VectorD
Solve for 'x' in the equation 'a*x = b' where 'a' is 'this' matrix.
Solve for 'x' in the equation 'a*x = b' where 'a' is 'this' matrix.
- b
the constant vector.
- Definition Classes
- SparseMatrixD → MatriD
-
def
solve(lu: (MatriD, MatriD), b: VectoD): VectorD
Solve for 'x' in the equation 'l*u*x = b' (see lud above).
Solve for 'x' in the equation 'l*u*x = b' (see lud above).
- lu
the lower and upper triangular matrices
- b
the constant vector
- Definition Classes
- SparseMatrixD → MatriD
-
def
solve(l: MatriD, u: MatriD, b: VectoD): VectorD
Solve for x in the equation l*u*x = b (see lud above).
Solve for x in the equation l*u*x = b (see lud above).
- l
the lower triangular matrix
- u
the upper triangular matrix
- b
the constant vector
- Definition Classes
- SparseMatrixD → MatriD
-
def
sum: Double
Compute the sum of this sparse matrix, i.e., the sum of its elements.
Compute the sum of this sparse matrix, i.e., the sum of its elements.
- Definition Classes
- SparseMatrixD → MatriD
-
def
sumAbs: Double
Compute the abs sum of this matrix, i.e., the sum of the absolute value of its elements.
Compute the abs sum of this matrix, i.e., the sum of the absolute value of its elements. This is useful for comparing matrices (a - b).sumAbs
- Definition Classes
- SparseMatrixD → MatriD
-
def
sumLower: Double
Compute the sum of the lower triangular region of this sparse matrix.
Compute the sum of the lower triangular region of this sparse matrix.
- Definition Classes
- SparseMatrixD → MatriD
-
def
swap(i: Int, k: Int, col: Int = 0): Unit
Swap the elements in rows 'i' and 'k' starting from column 'col'.
Swap the elements in rows 'i' and 'k' starting from column 'col'.
- i
the first row in the swap
- k
the second row in the swap
- col
the starting column for the swap (default 0 => whole row)
- Definition Classes
- MatriD
-
def
swapCol(j: Int, l: Int, row: Int = 0): Unit
Swap the elements in columns 'j' and 'l' starting from row 'row'.
Swap the elements in columns 'j' and 'l' starting from row 'row'.
- j
the first column in the swap
- l
the second column in the swap
- row
the starting row for the swap (default 0 => whole column)
- Definition Classes
- MatriD
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
t: SparseMatrixD
Transpose this sparse matrix (rows => columns).
Transpose this sparse matrix (rows => columns).
- Definition Classes
- SparseMatrixD → MatriD
-
def
times_s(b: SparseMatrixD): SparseMatrixD
Multiply this sparse matrix by sparse matrix b using the Strassen matrix multiplication algorithm.
Multiply this sparse matrix by sparse matrix b using the Strassen matrix multiplication algorithm. Both matrices (this and b) must be square. Although the algorithm is faster than the traditional cubic algorithm, its requires more memory and is often less stable (due to round-off errors). FIX: could be make more efficient using a virtual slice (vslice) method.
- b
the matrix to multiply by (it has to be a square matrix)
- See also
http://en.wikipedia.org/wiki/Strassen_algorithm
-
def
toDense: MatriD
Convert 'this' matrix to a dense matrix.
Convert 'this' matrix to a dense matrix.
- Definition Classes
- SparseMatrixD → MatriD
-
def
toInt: MatriI
Convert 'this'
MatriD
into aMatriI
.Convert 'this'
MatriD
into aMatriI
.- Definition Classes
- SparseMatrixD → MatriD
-
def
toString(): String
Show the non-zero elements in this sparse matrix.
Show the non-zero elements in this sparse matrix.
- Definition Classes
- SparseMatrixD → AnyRef → Any
-
def
trace: Double
Compute the trace of this sparse matrix, i.e., the sum of the elements on the main diagonal.
Compute the trace of this sparse matrix, i.e., the sum of the elements on the main diagonal. Should also equal the sum of the eigenvalues.
- Definition Classes
- SparseMatrixD → MatriD
- See also
Eigen.scala
-
def
update(ir: Range, jr: Range, b: MatriD): Unit
Set a slice this matrix row-wise on range ir and column-wise on range jr.
Set a slice this matrix row-wise on range ir and column-wise on range jr. Ex: a(2..4, 3..5) = b
- ir
the row range
- jr
the column range
- b
the matrix to assign
- Definition Classes
- SparseMatrixD → MatriD
-
def
update(i: Int, u: SortedLinkedHashMap[Int, Double]): Unit
Set this sparse matrix's row at the i-th index position to the sorted-linked-map u.
Set this sparse matrix's row at the i-th index position to the sorted-linked-map u.
- i
the row index
- u
the sorted-linked-map of non-zreo values to assign
-
def
update(i: Int, u: VectoD): Unit
Set this sparse matrix's row at the i-th index position to the vector u.
Set this sparse matrix's row at the i-th index position to the vector u.
- i
the row index
- u
the vector value to assign
- Definition Classes
- SparseMatrixD → MatriD
-
def
update(i: Int, j: Int, x: Double): Unit
Set this sparse matrix's element at the i,j-th index position to the scalar x.
Set this sparse matrix's element at the i,j-th index position to the scalar x. Only store x if it is non-zero.
- i
the row index
- j
the column index
- x
the scalar value to assign
- Definition Classes
- SparseMatrixD → MatriD
-
def
update(i: Int, jr: Range, u: VectoD): Unit
Set a slice of 'this' matrix row-wise at index 'i' and column-wise on range 'jr' to vector 'u'.
Set a slice of 'this' matrix row-wise at index 'i' and column-wise on range 'jr' to vector 'u'. Ex: a(2, 3..5) = u
- i
the row index
- jr
the column range
- u
the vector to assign
- Definition Classes
- MatriD
-
def
update(ir: Range, j: Int, u: VectoD): Unit
Set a slice of 'this' matrix row-wise on range 'ir' and column-wise at index 'j' to vector 'u'.
Set a slice of 'this' matrix row-wise on range 'ir' and column-wise at index 'j' to vector 'u'. Ex: a(2..4, 3) = u
- ir
the row range
- j
the column index
- u
the vector to assign
- Definition Classes
- MatriD
-
def
upperT: MatriD
Return the upper triangular of 'this' matrix (rest are zero).
Return the upper triangular of 'this' matrix (rest are zero).
- Definition Classes
- SparseMatrixD → MatriD
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
write(fileName: String): Unit
Write 'this' matrix to a CSV-formatted text file with name 'fileName'.
Write 'this' matrix to a CSV-formatted text file with name 'fileName'.
- fileName
the name of file to hold the data
- Definition Classes
- SparseMatrixD → MatriD
-
def
zero(m: Int, n: Int): MatriD
Create an m-by-n matrix with all elements initialized to zero.
Create an m-by-n matrix with all elements initialized to zero.
- m
the number of rows
- n
the number of columns
- Definition Classes
- SparseMatrixD → MatriD
-
def
~^(p: Int): SparseMatrixD
Raise this sparse matrix to the pth power (for some integer p >= 2).
Raise this sparse matrix to the pth power (for some integer p >= 2). Caveat: should be replace by a divide and conquer algorithm.
- p
the power to raise this matrix to
- Definition Classes
- SparseMatrixD → MatriD


Connect button not working? Try clicking this instead!
Want to download the Desktop version of Discord? Click here
Want to download the Mac version of Discord? Click here
Want to download the Android version of Discord? Click here
Want to download the Android version of Discord? Click here


Take a look at the gallery of d3 samples and the d3 cheat sheet and try and connect your own data to the visualistion.
Local bristol data here: Bristol open data project
For the really ambitious... try this: multi-dimensional library


ABS
Profile
|
|
|
|
|
Online People
ABC
ABC
ABC
ABC
ABC
Upload Images
Uploading your Post
Share
News Feeds


|
Flockers
By IsisLab
|
This is a simple example of "Boids"-style flocking, hastily put together late one night at the SwarmFest 2004 conference. It's much simpler and somewhat faster than our Woims and Woims3D models, which employ sinusoidal movement of multiple worm segments, mostly for fun. Incidentally, Craig Reynolds won a techincal Oscar (Scientific and Engineering) for his Boids algorithm.
In this model, some N flockers flock about in a toroidal landscape. Each flocker moves one step in the direction of a vector it has computed. This vector is the weighted sum of five unit vectors:
- Avoidance: A vector away from other flockers. This is computed as the sum, over all neighbors (dead ones included), of a vector to away from the neighbor, modified so that its magnitued is 1/d the distance to the neighbor (so close neighbors are much stronger a repelling force).
- Cohesion: A vector towards the "center of mass" of nearby flockers. This is computed as the sum, over all live neighbors, of a vector towards the neighbor.
- Momentum: A vector in the direction the flocker went last time.
- Coherence: A vector in the direction other flockers are going. This is computed as the sum, over all live neighbors, of the momentum vector of each neighbor.
- A random vector.
All these parameters affect the model as it is running. We have pre-weighted these values so that 1.0 for each one results in a nice flock. Try changing the values and see what happens.
Some additional model parameters which only affect newly-started models:
- Number of Flockers: self-explanatory.
- Dead Flocker Probability: the probability that a flocker will be born dead. We include dead flockers to make for interesting obstacles.
- Height and Width: the dimensions of the environment.
- Neighborhood: how many units in each direction a flocker scans to determine nearby flockers. Changing this has two effects. First, a bigger neighborhood results in stronger cohesion and coherence. Second, a bigger neighborhood results in slower computation, because many more neighbors will be considered. The drop-off is O(n^2) in neighborhood distance. You can also see the effect of more neighbors by deleting Avoidance, resulting in the flockers collapsing and the system slowing as tons of flockers fill the same neighborhood region. This provides a good tutorial for understanding the importance of a good discretization setting for Continuous2D and Continuous3D fields in MASON.


Choose vimrc commands below.
Looking for more commands?
Contribute!
What's a vimrc?
Your vimrc file is generated here.
""" Created with https://github.com/dawsonbotsford/vimrcBuilder """
Select all text


Home
User
Contact
About
For more info
Tel: 021326751
Fax: 345632134
Visit our HTML tutorial
My First Google Map


--- title: Cards section: Components ---
Use classes
aspect-ratio-item-top-left
,aspect-ratio-item-top-right
,aspect-ratio-item-bottom-right
, oraspect-ratio-item-top-left
to position other components relative to the corners inside theaspect-ratio
component.
Use
card-row
withautofit-col-expand
andautofit-col
to create a number of custom horizontal cards.autofit-col-expand
fills the remaining space andautofit-col
is only as wide as its content inside.```
```
Two
.autofit-col
's no.autofit-col-expand
.```
```
Two
.autofit-col-expand
's no.autofit-col
.```
```
Nest
card-row
incard-body
on to add some spacing around a horizontal card.```
```
Vertically align content by setting
justify-content
toflex-start
,center
, orflex-end
onautofit-col
.Horizontally align content by setting
text-align
toleft
,center
, orright
onautofit-col
.You can also use the Bootstrap 4's helper classes
justify-content-start
,justify-content-center
, orjustify-content-end
oncard-row
to align content in all columns inside the row.
Add gutters to a specific card card column by using the class
autofit-col-gutters
.
Use classes
rounded
,rounded-circle
, orrounded-0
on the card to quickly shape the borders.
Use classes
card-item-first
andcard-item-last
on elements that appear at the beginning or ending of your card. It styles the border-radius to match the card's border-radius. These classes work similar to Bootstrap 4's.card-img-top
and.card-img-bottom
but also covers left and right.
Administrator
Wings eu, pumpkin spice robusta, kopi-luwak mocha caffeine froth grounds.
Use
``````
to create a horizontal division between content inside a card.
To make the whole card clickable just wrap the checkbox and card in:
```
```
To make the whole card clickable just wrap the radio input and card in:
```
```
We have created a pattern to add checkboxes to cards, just wrap the checkbox and card in:
```
...
```
active
class when the input is checked/unchecked.


| | |
- check_sides(run, temp, theta, fin)
- Recursive function takes in each side and continuously checks for sides to meet up
Input: sides that are being folded, temporary dict with sides to check against, theta,
full list of sides_old_coordinates
Output: final theta, dictionary of final sides
- find_intersection_distances(p1, y1, x1, y2, x2)
- main(sides, xy_coord)
- Main function that creates a dictionary with the two lists and calls other functions
Input: list of sides normalized to 0,0, and list of actual side coordinates
Output: the list of x,y,z coordinates of the final folded shape
- make_sides(sides, theta)
- Function iterates through the sides and folds each one, returning new coordinates
Input: sides dictionary, theta
Output: the transformed sides
- move_to_actual_coord(old_side, side_dict, side_num, theta)
- Change the xy coordinates of the sides to the correct values from the original image
Input: side coordinates, sides dictionary
Output: new side coordinates in the sides dictionary
- output(theta, final_list)
- Function takes each point and returns the x,y,z coordinates in three lists.
Input: theta (for testing), final sides dictionary
Output: three lists of x,y,z
- transform_side(side_num, side_dict, theta)
- Transform the coordinates of the side onto the perpendicular plane using Euler-Rodrigues formula
Input: side coordinates, sides dictionary, theta
Output: new coordinates
|


MitMirroR
Profile
Register
About
incorrect credentials!
Email
Password
Keep me signed in
Forgot Password?
Create an account!


Type of AR
Markerless
Markerbased
Markerless AR
Select Obj File of the 3D object
Select mtl File of the 3D object


your results are being checked, please wait and return later when the host checks your answers.
click me to check your answers.


The Department of Education should be a responsible steward of the nation’s colleges and universities. These days it’s acting more like a debt collector for a predatory lender.
Today’s announcement of the sale of 56 Corinthian College campuses to Education Credit Management Corporation really drives this fact home. As former Everest student Geovanna Nieves noted, “This is another slap in the face from the DOE.”
We object to this sale for three main reasons.
1) It prevents current Corinthian students at the campuses that are sold from claiming the complete discharge of their debt under the Higher Education Act.
2) It ensures that Corinthian’s wealthy shareholders make a profit on a failing business.
3) It helps to revitalize these campuses by rebranding them under a new name.
Corinthian will get a fresh start, but students are stuck with debts they were deceived into. The DOE facilitated the robbery of over half a million current and former Corinthian students, yet the Department is effectively arguing that too many people were ripped off for it to pursue justice.
As Everest student Heather Wright said of the sale, “This is ridiculous.
The Department’s claim that it is looking out for the best interests of students and the public is a smokescreen that masks the agency’s real agenda. If Corinthian closed its doors, current students would be entitled to a complete erasure of their debts. By approving this sale, the DOE illustrates the lengths to which it will go to keep students from getting their money back.
The sale of dozens of campuses to ECMC is a further sign that the Education Department is primarily interested in protecting investors and its own reputation. According to the New York Times, ECMC has been “the main private entity hired by the Department of Education to fight student debtors who file for bankruptcy on federal loans.” The company has recently has been accused of “ruthless tactics,” including demanding payments from people with terminal cancer and from those who had already paid off their debts.
Makenzie Vasquez, who attended Everest’s San Jose campus, called the the ECMC sale “outrageous. How can the DOE allow one horrible company to sell to another and act as if that fixes anything?” she asked. “I’m tired of these huge corporations that aren’t even people having more rights than we do.”
The Department’s ultimate loyalty to predatory lenders and to ensuring investor profits at all costs – even at the expense of defrauded students – is clear. We note that the California Attorney General’s office and other states are still pursuing their cases against Corinthian. We join with current and former Corinthian students – and with all student debtors – to fight this decision and to demand the discharge of these illegitimate debts.