Asoundrc
|
Why asoundrc?
What is it good for, why do I want one?
Neither the user-side .asoundrc
nor the asound.conf
configuration files are required for ALSA to work properly. Most applications will work without them. These files are used to allow extra functionality, such as routing and sample-rate conversion, through the alsa-lib layer.
The actual reason that most applications will work without these user-side custom config files is that usually a default install of alsa-lib provides a sufficiently capable setup consisting of hierarchical config files (which always make use of the standard .asoundrc format syntax as well), which are specifically capable of supporting certain soundcard brands each.
Thus, let's start with a quick overview of how ALSA config file framework evaluation is composed, globally:
Global view of ALSA config file framework, executive summary
The alsa-lib package (at least on Debian libasound2-data 1.0.27) provides the /usr/share/alsa/alsa.conf file as the main entry point. That file is responsible for including the full list of potential .asoundrc-format-type files on the system. It contains a reference to the ALSA "DATADIR" (Debian: /usr/share/alsa/). It continues by loading the DATADIR's cards/aliases.conf file: that one defines translation mappings from the kernel driver's sound card name (as listed at /proc/asound/cards, or aplay -Ll) to a "more detailed" description string. That "more detailed name" of a sound card then gets used to lookup a corresponding card-specific config file at DATADIR/cards/CARD.conf. And THAT card-specific file then attempts to provide a maximally elegant sound setup for its specific card brand, by compensating for various limitations of cards (e.g. use dmix to combat single-stream playback only, or stereo downmix to lessen a mono-output-only restriction). Finally (to support those cases where the standard setup of a soundcard is deficient/lacking, or custom plugin setup is desired), alsa.conf loads a system-global custom settings file /etc/asound.conf and a per-user custom settings file ~/.asoundrc.
So, the objective should be to achieve having the common alsa-lib configuration file framework enhanced by default in the best possible manner for each specific soundcard brand, to avoid the need of creating manually customized config files in all standard cases.
With this global overview done and cared for, let's have a look at the actual configuration format of alsa-lib files.
The .asoundrc file format
This file allows you to have more advanced control over your card/device. The .asoundrc
file consists of definitions of the various cards available in your system. It also gives you access to the pcm plugins in alsa-lib. These allow you to do tricky things like combine your cards into one or access multiple I/Os on your multichannel card.
Where does asoundrc live?
The asoundrc file is typically installed in a user's home directory
$HOME/.asoundrc
and is called from
/usr/share/alsa/alsa.conf
It is also possible to install a system wide configuration file as
/etc/asound.conf
When an alsa application starts both configuration files are read.
Below is the most basic definition.
The default plugin
Make a file called .asoundrc in your home and/or root directory.
vi /home/xxx/.asoundrc
copy and paste the following into the file then save it.
pcm.!default { type hw card 0 } ctl.!default { type hw card 0 }
The keyword default
is defined in the ALSA lib API and will always access hw:0,0
— the default device on the default soundcard. Specifying the !default
name supersedes the one defined in the ALSA lib API.
Now you can test:
aplay -D default test.wav
The naming of PCM devices
A typical asoundrc starts with a 'PCM hw type'. This gives an ALSA application the ability to start a virtual soundcard (plugin, or slave) by a given name. Without this, the soundcard(s)/devices(s) must be accessed with names like hw:0,0
or default. For example:
aplay -D hw:0,0 test.wav
or with ecasound
ecasound -i test.wav -o alsa,hw:0,0
The numbers after hw:
stand for the soundcard number and device number. This can get confusing as some sound "cards" are better represented by calling them sound "devices", for example USB sounddevices. However they are still "cards" in the sense that they have a specific driver controlling a specific piece of hardware. They also correspond to the index shown in
/proc/asound/cards
As with most arrays the first item usually starts at 0
not 1
. This is true for the way pcm devices (physical I/O channels) are represented in ALSA. Starting at pcm0c
(capture), pcm0p
(playback).
We use subdevices mainly for hardware which can mix several streams together. It is impractical to have 32 devices with exactly the same capabilities. The subdevices can be opened without a specific address, so the first free subdevice is opened. Also, we temporarily use subdevices for hardware with a lot of streams (I/O connectors) — for example MIDI. There are several limits given by used minor numbers (8 PCM devices per card, 8 MIDI devices per card etc.).
For example, to access the first device on the first soundcard/device, you would use
hw:0,0
to access the first device on the second soundcard/device, you would use
hw:1,0
to access the second device on the third soundcard/device, you would use
hw:2,1
The Control device
The control device for a card is the way that programs modify various "controls" on the card. For many cards this includes the mixer (but some cards, for example the rme9652, have no mixer). However, they do still have a number of other controls and some programs like JACK need to be able to access them. Examples include the digital I/O sync indicators, sample clock source switch and so on.
Aliases
With the 'PCM hw type' you are able to define aliases for your devices. The syntax for this definition is:
pcm.NAME { type hw # Kernel PCM card INT/STR # Card name or number [device] INT # Device number (default 0) [subdevice] INT # Subdevice number, -1 first available (default -1) mmap_emulation BOOL # enable mmap emulation for ro/wo devices }
For example, this gives your first soundcard an alias:
pcm.primary { type hw card 0 device 0 }
Now you can access this card by the alias 'primary
'.
aplay -D primary test.wav
Plugins
Q: What are plugins?
A: In ALSA, PCM plugins extend functionality and features of PCM devices. The plugins deal automagically with jobs like naming devices, sample rate conversions, sample copying among channels, writing to a file, joining sound cards/devices for multiple inputs/outputs (not sample synced), using multi channel sound cards/devices and other possibilities left for you to explore. To make use of them, you need to create a virtual slave device.
To see a full list of plugins and options, go to the alsa-lib documentation. The following is a brief introduction.
A very simple slave could be defined as follows:
pcm_slave.sltest { pcm "hw:1,0" }
This defines a slave without any parameters. It's nothing more than another alias for your sound device. The slightly more complicated thing to understand is that parameters for 'pcm types' must be defined in the slave-definition-block. Let's setup a rate-converter which shows this behaviour.
pcm_slave.sl2 { pcm "hw:1,0" rate 48000 } pcm.rate_convert { type rate slave sl2 }
Now you can call this newly created virtual device by:
aplay -D rate_convert test.wav
Which automatically converts your samples to a 44.1 kHz sample rate while playing. It's not very useful because most players and alsa converts samples to the right sample rate which your soundcard is capable of, but you can use it for a conversion to a lower static sample rate for example.
For conciseness, this can be also rewritten using nested device definitions:
pcm.rate_convert { type rate slave { pcm rate 48000 } }
A more complex tool for conversion is the pcm type plug. the syntax is:
type plug # Format adjusted PCM slave STR # Slave name (see pcm_slave) # or slave { # Slave definition pcm STR # Slave PCM name # or pcm { } # Slave PCM definition [format STR] # Slave format (default nearest) or "unchanged" [channels INT] # Slave channels (default nearest) or "unchanged" [rate INT] # Slave rate (default nearest) or "unchanged" } route_policy STR # route policy for automatic ttable generation # STR can be 'default', 'average', 'copy', 'duplicate' # average: result is average of input channels # copy: only first channels are copied to destination # duplicate: duplicate first set of channels # default: copy policy, except for mono capture - sum ttable { # Transfer table (bidimensional compound of # cchannels * schannels numbers) CCHANNEL { SCHANNEL REAL # route value (0.0 ... 1.0) } }
We can use it as follows:
pcm_slave.sl3 { pcm "hw:1,0" format S16_LE channels 1 rate 16000 } pcm.complex_convert { type plug slave sl3 }
By calling it with:
aplay -vD complex_convert test.wav
You will convert the sample during playing to the sample format: S16_LE, one channel and a sample rate of 16 kHz. As you called aplay with the verbose option -v you see this options as it appears as it comes from the original file. with:
aplay -v test.wav
You see the original settings of the file.
Software mixing
Software mixing is the ability to play multiple sound files or applications at the same time through the same device. There are many ways to have software mixing in the Linux environment. Usually it requires a server application such as ARTSD, ESD, JACK... The list is large and the apps can often be confusing to use.
dmix
These days we have a native plugin for ALSA called the dmix
(direct mixing) plugin. It allows software mixing in an easy to use syntax and without the hassle of installing/understanding a new application first.
A very interesting and potentially extremely useful aspect of this plugin is using it combined with the default plugin name. In theory this means all applications that have native ALSA support will share the sound device. In practice not many applications are able to take advantage of this functionality yet. However if you have time to test and report your findings to the application developers it is worth a try:
pcm.!default { type plug slave.pcm "dmixer" } pcm.dmixer { type dmix ipc_key 1024 slave { pcm "hw:1,0" period_time 0 period_size 1024 buffer_size 4096 rate 44100 } bindings { 0 0 1 1 } } ctl.dmixer { type hw card 0 }
(To use it with your own name just change the word !default
above)
Now try:
aplay -f cd -D default test.wav
on multiple consoles.
Some notes:
The dmix PCM name is already defined in the global configuration file /usr/share/alsa/alsa.conf
.
- The default sample rate for this device is 48000Hz. If you would like to change it use:
aplay -D"plug:'dmix:RATE=44100'" test.wav
- An example command for dmix plugin to use 44100Hz sample-rate and hw:1,0
output device:
aplay -Dplug:\'dmix:SLAVE=\"hw:1,0\",RATE=44100\' test.wav
- The dmix PCM name is already defined in the global configuration file /usr/share/alsa/alsa.conf
.
Defaults are:
SLAVE="hw:0,0",RATE=48000
NB the dmix plugin is not based on client/server architecture, but it writes directly to the soundcard's DMA buffer. There is no limit to the amount of instances that can be run at one time.
dsnoop
While the dmix plugin is for mixing multiple output(playback) streams together, if you want to use multiple input(capture) clients you need to use the dsnoop
plugin:
pcm.mixin { type dsnoop ipc_key 5978293 # must be unique for all dmix plugins!!!! ipc_key_add_uid yes slave { pcm "hw:0,0" channels 2 period_size 1024 buffer_size 4096 rate 44100 periods 0 period_time 0 } bindings { 0 0 0 1 } }
JACK plugin
This plugin allows the user to connect applications that support alsa natively to the JACK daemon.
To compile and install jack, you need to move to src/pcm/ext
directory, and run "make jack
" and "make install-jack
".
this is intentional.
To use the JACK plugin you will need to add the following to your .asoundrc.
pcm.jackplug { type plug slave { pcm "jack" } } pcm.jack { type jack playback_ports { 0 alsa_pcm:playback_1 1 alsa_pcm:playback_2 } capture_ports { 0 alsa_pcm:capture_1 1 alsa_pcm:capture_2 } }
Now, you can use:
aplay -Djackplug somefile arecord -Djackplug somefile
Virtual multi channel devices
If you would like to link two or more ALSA devices together so that you have a virtual multi channel device it is possible. However this will not create the mythical "multi-channel soundcard out of el-cheapo consumer cards". The real devices will drift out of sync over time. It is sometimes helpful to make applications that can for example see one 4 channel card to allow for flexible routing if they can't easily be made to talk to multiple cards (making use of JACK being one example).
Copy and paste the following into your asoundrc.
# create a virtual four-channel device with two sound devices: # This is in fact two interleaved stereo streams in # different memory locations, so JACK will complain that it # cannot get mmap-based access. see below. pcm.multi { type multi; slaves.a.pcm "hw:0,0"; slaves.a.channels 2; slaves.b.pcm "hw:1,0"; slaves.b.channels 2; bindings.0.slave a; bindings.0.channel 0; bindings.1.slave a; bindings.1.channel 1; bindings.2.slave b; bindings.2.channel 0; bindings.3.slave b; bindings.3.channel 1; } # JACK will be unhappy if there is no mixer to talk to, so we set # this to card 0. This could be any device but 0 is easy. ctl.multi { type hw; card 0; } # This creates a 4 channel interleaved pcm stream based on # the multi device. JACK will work with this one. pcm.ttable { type route; slave.pcm "multi"; slave.channels 4; ttable.0.0 1; ttable.1.1 1; ttable.2.2 1; ttable.3.3 1; } # see above. ctl.ttable { type hw; card 0; }
This will give you xruns, but it's suitable for testing. To test the above setting feed an audio signal to the real sound devices play it back and listen to it with an external mixer:
arecord -f S16_LE -r 44100 -c 4 -D multi | aplay -f S16_LE -r 44100 -c 4 -D multi
To start JACK with the new device, use
jackd [-a] -R [-v] -d alsa -d ttable [-p 1024]
Bindings explained
The above example for a virtual multi channel device uses bindings to make the connections work. The following is a more advanced asoundrc for 2 RME Hammerfalls which is a professional multichannel sound device. Below is a full explanation of how bindings work.
# This is for two RME Hammerfall cards. They have been conceptually split into rows # and will be mapped to ALSA channels 0-27: with channels 0-7 and 16-23 on rme9652_0 and channels 8-15 on # rme9652_1, and finally channels 24-25 of both cards, used as two stereo channels, mapped to ALSA channels 24-27 (while the others are mono). # eg. ALSA channels on card1 = rme9652_0 # | 0 1 2 3 4 5 6 7 | # | 8 9 10 11 12 13 14 15 | # | 24 25| # # ALSA channels on card2 = rme9652_1 # | 16 17 18 19 20 21 22 23 | # | 26 27| pcm_slave.rme9652_s { pcm rme9652_0 } pcm.rme9652_1 { type hw card 1 } ctl.rme9652_1 { type hw card 1 } pcm.rme9652_0 { type hw card 0 } ctl.rme9652_0 { type hw card 0 } ctl.rme9652_48 { type hw card 0 } pcm.rme9652_48 { type multi; slaves.a.pcm rme9652_0; slaves.a.channels 26; slaves.b.pcm rme9652_1; slaves.b.channels 26; # Use rme9652_0 ch 0-7 mapped to ALSA ch 0-7 bindings.0.slave a; bindings.0.channel 0; bindings.1.slave a; bindings.1.channel 1; bindings.2.slave a; bindings.2.channel 2; bindings.3.slave a; bindings.3.channel 3; bindings.4.slave a; bindings.4.channel 4; bindings.5.slave a; bindings.5.channel 5; bindings.6.slave a; bindings.6.channel 6; bindings.7.slave a; bindings.7.channel 7; # Use rme9652_0 ch 16-23 mapped to ALSA ch 8-15 bindings.8.slave a; bindings.8.channel 16; bindings.9.slave a; bindings.9.channel 17; bindings.10.slave a; bindings.10.channel 18; bindings.11.slave a; bindings.11.channel 19; bindings.12.slave a; bindings.12.channel 20; bindings.13.slave a; bindings.13.channel 21; bindings.14.slave a; bindings.14.channel 22; bindings.15.slave a; bindings.15.channel 23; # Use rme9652_1 ch 8-15 mapped to ALSA ch 16-23 bindings.16.slave b; bindings.16.channel 8; bindings.17.slave b; bindings.17.channel 9; bindings.18.slave b; bindings.18.channel 10; bindings.19.slave b; bindings.19.channel 11; bindings.20.slave b; bindings.20.channel 12; bindings.21.slave b; bindings.21.channel 13; bindings.22.slave b; bindings.22.channel 14; bindings.23.slave b; bindings.23.channel 15; # stereo channels: slave a+b ch 24-25 mapped to ALSA ch 24-27 bindings.24.slave a; bindings.24.channel 24; bindings.25.slave a; bindings.25.channel 25; bindings.26.slave b; bindings.26.channel 24; bindings.27.slave b; bindings.27.channel 25; }
What is happening?
There are two sound cards which are linked with a wordclock pipe. That allows them to keep sample sync with each other which is very important for multichannel work. If the sample rates are not in sync then your sounds become out of time with each other.
In this example each sound card has a number of physical channels being used: 18 (a) + 10 (b). They are represented in /proc/asound/card
x as pcm
Xc
(capture) and pcm
Xp
(playback). Where X equals the number of the physical input/output (i/o) channels starting at 0.
If you look at the lines:
type multi; slaves.a.pcm rme9652_0; slaves.a.channels 26;
You can see that the card has been nicknamed "a
" and given a range of 26 channels. You can assign the card any number of channels you want but you can only use as many channels as the card has physically available. The bindings start at the first available pcm device for the card ie. pcm0c pcm0p
- and move upwards sequentially from there.
The first card for this file has 18 physical pcm devices. Nine of them are capture devices ie. pcm0c pcm1c pcm2c
... pcm8c
, each with corresponding playback channels ie. pcm0p pcm1p pcm2p
... pcm8p
. The second card has 10 physical pcm devices ie. pcm0c pcm1c pcm2c
... pcm9c
.
If you look at the lines:
bindings.0.slave a; bindings.0.channel 0; bindings.1.slave a; bindings.1.channel 1;
The first binding points to the first available pcm device on the card represented as "a
". The second binding points to the second available pcm device on "a
" and so on up to the last one available. We then assign a channel number to the binding so that the channels on the new virtual "soundcard" we have created are easy for us to access.
Another way of saying it is:
address of.the first channel on my new soundcard.using my real soundcard called "a"; make this address of.the first channel on my new soundcard.be the first pcm device on my new soundcard;
address of.the second channel on my new soundcard.using my real soundcard called "a"; make this address of.the second channel on my real soundcard.be the second pcm device on my new soundcard;
Referenced applications
- aRTsd - the aRTs sound server was the basis of desktop sound for KDE 3.
- ESD - the Enlightened Sound Daemon mixes several audio streams for playback by a single audio device.
- Ecasound - a commandline multitrack recorder and editor with various GUI apps.
- JACK - Jack Audio Connection Kit. If you don't know this app you don't know JACK.
Further reading
- A close look at ALSA explaining ALSA and the asoundrc in particular from A to Z. By Volker Schatz
- .asoundrc at the Unofficial wiki


Dunder Mifflin Inc. (stock symbol DMI) is a micro-cap regional paper and office supply distributor with an emphasis on servicing small-business clients.


Reports "good code is red" problems for Java/Groovy code.
Must be run in batch mode, IDE internal mode must be enabled.


Select which notifications to delete
|
|
Subject | Date received |
|---|---|---|
|
|
Unread:
{{ notification.type | notificationType }}
|
{{ notification.created | longDate }} |
You have no notifications


We’d love to hear from you! Whether it is a query compliment or complaint, we’re always available – just an email or phone call away.
Please fill out the fields below and we'll get back to you.


Button Example
Colors
Type & Style
Normal (button-type="normal")
NORMAL
TEXT
OUTLINE
ACTIVE
DISABLED
LINK
DISABLED LINK
Primary (button-type="primary")
PRIMARY
TEXT
OUTLINE
ACTIVE
DISABLED
LINK
DISABLED LINK
Submit (button-type="submit")
SUBMIT
TEXT
OUTLINE
ACTIVE
DISABLED
LINK
DISABLED LINK
Danger (button-type="danger")
DANGER
TEXT
OUTLINE
ACTIVE
DISABLED
LINK
DISABLED LINK
Round Shape
PRIMARY
Icon & Content
Text Only
Text Left
Text Right
More Icons
With Badges
Normal Badge 99+
Primary Badge 999+
Success Badge 9+
Warning Badge 5
Danger Badge 1
Button Group
Simple
Button 1
Button 2
Button 3
Primary Type
Button 1
Button 2
Button 3
Round Shape
Button 1
Button 2
Button 3
Split Button
Split Button
Real Split Button


CURLOPT_COOKIEJAR explained
NAME
CURLOPT_COOKIEJAR - file name to store cookies to
SYNOPSIS
#include <curl/curl.h>
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_COOKIEJAR, char *filename);
DESCRIPTION
Pass a filename as char *, zero terminated. This will make libcurl write all internally known cookies to the specified file when curl_easy_cleanup is called. If no cookies are known, no file will be created. Specify "-" as filename to instead have the cookies written to stdout. Using this option also enables cookies for this session, so if you for example follow a location it will make matching cookies get sent accordingly.
Note that libcurl doesn't read any cookies from the cookie jar. If you want to read cookies from a file, use CURLOPT_COOKIEFILE.
If the cookie jar file can't be created or written to (when the curl_easy_cleanup is called), libcurl will not and cannot report an error for this. Using CURLOPT_VERBOSE or CURLOPT_DEBUGFUNCTION will get a warning to display, but that is the only visible feedback you get about this possibly lethal situation.
Since 7.43.0 cookies that were imported in the Set-Cookie format without a domain name are not exported by this option.
The application does not have to keep the string around after setting this option.
DEFAULT
PROTOCOLS
EXAMPLE
CURL *curl = curl_easy_init(); if(curl) { curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin"); /* export cookies to this file when closing the handle */ curl_easy_setopt(curl, CURLOPT_COOKIEJAR, "/tmp/cookies.txt"); ret = curl_easy_perform(curl); /* close the handle, write the cookies! */ curl_easy_cleanup(curl); }
AVAILABILITY
RETURN VALUE
Returns CURLE_OK if HTTP is supported, CURLE_UNKNOWN_OPTION if not, or CURLE_OUT_OF_MEMORY if there was insufficient heap space.
SEE ALSO
CURLOPT_COOKIEFILE, CURLOPT_COOKIE, CURLOPT_COOKIELIST
This HTML page was made with roffit.


The rotary switch selects the Collector series resistor value. The
resistor limits the current available from the Collector sweep Voltage
source. It also is used as the current measuring device. For measuring
higher current values in the mA range, select lower resistors such as
the 500 ohm. For current in the uA range select a higher value resistor
such as the 100K ohm. Current resolution is dependent on the value
selected. It is approximately 15V / (R * 4095). The 500 ohm resistor
has a resolution of abou 7uA. Noise generally makes
the smallest measured value many times the resolution. Resolution
is increased with slow scans and with averaging and filtering.
Resolution is not accuracy. Calibration helps with accuracy but there
are still non-linearities in the system.
The potentiometer adjusts the Collector sweep voltage amplitude. When
setting the collector voltage from the user inteface, the potentiometer
should be in the calibration
Cal position to obtain the correct collector
voltage output. Reducing the amplitude also reduces the DAC voltage
step size. A smoother waveform is possible for testing devices, such as
diode forward voltage characteristics, that need only low amplitude
excitation.
The
B-V / B-I toggle switch selects between a voltage output and a
current output on the Base output terminal. Base current steps are used
to test bipolar transistors such as NPN transistors. Base voltage steps
are used for testing field effect transistors such as MOS FETs. The
base voltage has a current compliance that is achieved with a 1K
resistor within the amplifier feedback loop. At 10V, the maximum
current before voltage drooping is 5mA. A zero volts, 15mA is
available. The resistor helps to protect the amplifier from capacitive
loading.
The
4.5X / 1X toggle is a gain switch for the collector voltage
measurement. At 1X, the voltage resolution is about 15V/4095 = 4mV.
Resolution is increased to about 1mV with the switch at 4.5X. To
prevent confusion in the high gain mode, the display is clipped above
3.3V. Without clipping, current changes that occur at higher voltages
would appear as a breakdown event at 3.3V. However, all data is saved
to the trace file.
The FS input is an 1/8th inch audio jack that is intended for a nomally
open foot switch. Closing the foot switch initiates a trace sweep
function. This allows hands free trace recording when probing a circuit.
Main


Maid Id : {{maid.id}}
Email : {{maid?.email}}
Contact : {{maid?.phone}}
Gender: {{maid?.gender}}
Expected Salary : {{maid?.salary}}
With Us Since: {{maid?.dateCreated | date: 'dd/MM/yyyy' }}
Marital Status: {{maid?.maritalStatus}}


We require you to create a personal access token to avoid hitting API limits. Click here to create a token with no scopes selected. Then paste the generated token below
Token saved, carry on to some great pages!
(Feel free to close this tab)


|
SideCar
|
Tuple representing a vector in 3-D space. More...
#include </Users/howes/src/sidecar/Algorithms/ABTracker/Vector.h>
Public Member Functions | |
| Vector () | |
| Default constructor. | |
| Vector (double x, double y, double z) | |
| Constructor using component values. More... | |
| Vector (const UnitVector &direction, double length) | |
| Constructor using direction and magnitude values. More... | |
| Vector (const Vector &from, const Vector &to) | |
| Constructor from two Vector objects. More... | |
| double | getX () const |
| Obtain the X component. More... | |
| double | getY () const |
| Obtain the Y component. More... | |
| double | getZ () const |
| Obtain the Z component. More... | |
| double | getMagnitude () const |
| Obtain the magnitude of the vector. More... | |
| double | getMagnitudeSquared () const |
| Obtain the squared magnitude of the vector. More... | |
| double | getDirection () const |
| Obtain the angle in radians of the vector in the X/Y plane and the Y axis (north) More... | |
| double | getElevation () const |
| Obtain the angle in radians of the vector in the Z/Y plane and the Y axis (0 elevation). More... | |
| Vector & | operator+= (const Vector &rhs) |
| Add component values from another vector to this one. More... | |
| Vector & | operator-= (const Vector &rhs) |
| Subtract component values of another vector from this one. More... | |
| Vector & | operator*= (double scale) |
| Multiply component vales by a given value. More... | |
| Vector & | operator/= (double scale) |
| Divide component vales by a given value. More... | |
| std::ostream & | print (std::ostream &os) const |
| Write out a textual representation of the Vector to the given C++ output stream. More... | |
Tuple representing a vector in 3-D space.
Supports basic vector/vector and vector/scalar operations. Borrowed from RWSL project. Calculates on demand magnitude and direction values.
NOTE: not sure if elevation and Z axis are handled properly. Need to be vetted.
| Vector::Vector | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
| Vector::Vector | ( | const UnitVector & | direction, |
| double | length | ||
| ) |
Constructor using direction and magnitude values.
| direction | UnitVector representing the direction of the vector |
| length | the magnitude of the vector |
| double Vector::getDirection | ( | ) | const |
| double Vector::getElevation | ( | ) | const |
Obtain the angle in radians of the vector in the Z/Y plane and the Y axis (0 elevation).
A well-formed vector would only have values in [0-PI/4].
Definition at line 81 of file Vector.cc.
References getMagnitude().
Referenced by getZ().
| double Vector::getMagnitude | ( | ) | const |
Obtain the magnitude of the vector.
Definition at line 54 of file Vector.cc.
References getMagnitudeSquared().
Referenced by getElevation(), and getZ().
| double Vector::getMagnitudeSquared | ( | ) | const |
Obtain the squared magnitude of the vector.
Definition at line 38 of file Vector.cc.
Referenced by getMagnitude(), SideCar::Algorithms::ABTrackerUtils::Track::getProximityTo(), and getZ().
|
inline |
|
inline |
|
inline |
Obtain the Z component.
Definition at line 67 of file Vector.h.
References getDirection(), getElevation(), getMagnitude(), getMagnitudeSquared(), operator*=(), operator+=(), operator-=(), operator/=(), and print().
| Vector & Vector::operator*= | ( | double | scale | ) |
Multiply component vales by a given value.
| scale | value to multiply with |
Definition at line 118 of file Vector.cc.
Referenced by getZ(), and operator/=().
| Vector & Vector::operator/= | ( | double | scale | ) |
Divide component vales by a given value.
| scale | value to divide with |
Definition at line 128 of file Vector.cc.
References operator*=().
Referenced by getZ().
| std::ostream& SideCar::Geometry::Vector::print | ( | std::ostream & | os | ) | const |


I'm Jenny Ballif, more commonly known as Science Mom, creator of educational videos and Science Mom Guides--pocket sized coloring books that you can fold from a single piece of paper.
I hope you'll take a few minutes to watch my videos, download the guides, and explore engaging science activities. And if you'd like to join me in my mission to bring the world more curiosity, wonder, and investigative thinking, check out my Patreon page! You can meet some of my wonderful patrons (cartoon versions of them) in the Periodic Table of Patrons below. Hover over the image below to view some of my patrons.


Win Probability Simulator
Home Goals Per Game
Away Goals Per Game
Simulate
Win Margin (Estimated and Actual)
Win Probability


Toggle Ground Elevation
WebGL is not supported on your platform/browser.
Elevation:
Based on
this sample
.


CAMERA
LIBRARY
MENU
HOME
ABOUT
CANON
NIKON
PENTAX
OTHERS
C
O
M
I
N
G
S
O
O
N
Oops!! Page not found!!
Please try one of the following pages...
HOME PAGE


EBM 549 Networked Entertainment - Fall 2015
Instructor: Dr. Ali Cengiz Beğen
Email: ali.begen AT karatay.edu.tr
Office Hours: On Tuesdays after the class (Please
make an appointment in advance)
Logistics
Location and Time: A-231 (2nd floor meeting room) - Tuesday 9:00am -
12:00pm (Note the class time and location change)
Website:
http://ali.begen.net/courses/ebm549/ebm549_f15.html Textbook:
There is no required textbook. The course material will consist of
readings from books, papers and online resources. You may find the
following books useful in different parts of the course:
This is a graduate course, so you will be expected to do a
significant amount of readings on your own.
Course Overview
Description: The objective of this course is to introduce
the key concepts involved with networked entertainment. This includes
concepts in generating, delivering and consuming multimedia content. The
course will briefly explain the theory and principles in coding,
packaging and securing multimedia data, while mostly focusing on the
methods for reliable and scalable transport over IP networks in the
context of IPTV, video-on-demand and streaming applications. The course
will also present the best practices in network and operating system
support for media transport, and the state-of-the-art in current
deployments. Prerequisites: Having
a solid computer
networking knowledge and programming skills is strongly recommended as
we will build on top of the basic networking concepts.
Grading
Grades (as of Jan. 25th)
- Midterm I - 20%
- Paper critique - 10%
- Each student will prepare a two-page concise summary and
critique of a research area of his/her choosing (from this list) and lead a
20-minute discussion session in the class (including a
presentation and Q&A session). The (electronic, no print
please) reports and presentations are due in the class on the
day of presentation. In the report and presentation, the
students should discuss the problem to solve, the solution
approach, main results and the next steps in this research area.
- Project - 40%
- The project will consist of reading, design, implementation,
testing, evaluation, report and demo/presentation.
- Midterm II - 20%
- Class participation - 10%
Important Dates (Subject to Change)
- Paper assignments: By week 5
- Project assignments: By week 5
- Midterm I: Nov. 24th
- Midterm II: Jan. 5th
- Project demos/presentations: Jan. 12th
Syllabus (Subject to Change)
The following is the planned syllabus. The subjects and dates may
change.
- Week 1 (Sept. 28th): No class
- Week 2 (Oct. 5th): No class
- Week 3 (Oct. 12th): Overview of multimedia data and applications
- Week 4 (Oct. 20th): Media coding and packaging
- Week 5 (Oct. 27th): Network protocols, layering, application layer, transport layer
- Week 6 (Nov. 3rd): Network layer, multicasting, forward error correction
- Week 7 (Nov. 10th) : Scheduling, rate control, traffic
shaping, adaptive playout, quality of service
- Week 8 (Nov. 17th): Introduction to HTTP adaptive streaming
- Week 9 (Nov. 24th): Midterm I (in the class)
- Week 10 (Dec. 1st): Video transport networks and services
- Week 11 (Dec. 8th): IPTV architectures, devices, protocols and
user experience
- Week 12 (Dec. 15th): Streaming concepts and research directions
- Week 13 (Dec. 22nd): Streaming concepts and research directions
- Week 14 (Dec. 29th): Cloud computing for multimedia services and
analytics in streaming
- Week 15 (Jan. 5th): Midterm II (in the class)
- Week 16 (Jan. 12th): Project presentations and discussions (Email
your reports and slides before the class)
|


SANTA CLARITA, Calif. — One person was killed and several others were injured Thursday during a shooting at a Southern California high school and the student gunman was in custody, authorities said.
The shooting occurred around 7:30 a.m. at Saugus High School in the city of Santa Clarita, about 30 miles (48 kilometers) northwest of downtown Los Angeles.
Henry Mayo Newhall Hospital tweeted that one female patient was dead, two males were in critical condition and one male was in good condition.
It was unclear if there were any other injured. Initial reports fluctuated as high as six.
Los Angeles County Sheriff Alex Villanueva tweeted that the suspect was in custody and was being treated at a hospital. He said the suspect was a student but gave no further information.
Television images showed deputies swarming the school and several people being moved on gurneys.
Lines of students were escorted from the school by armed deputies.
White House spokesman Judd Deere said President Donald Trump was monitoring the reports.
Saugus High School and other schools in the area were locked down.
Student Sharon Orelana Cordova told KNBC-TV she hid under a table in a nurse’s office until officers came to get her.
“When I got out I saw this person lying on the ground ... with blood all over,” she said.
Freshman Rosie Rodriguez was walking up the library stairs when she heard noises that “sounded like balloons” popping. When she saw other students running, she realized they were gunshots.
Still carrying a backpack laden with books, she ran across the street to a home, where a person she didn’t know gave shelter to her and about 10 other students.
During the more than hour they were there, students including Rodriguez called their families and texted with friends. Nobody in the house saw what happened directly.
“I just heard a lot of kids crying. We were scared,” Rodriguez said.
On a normal day, Rodriguez said, Saugus High School felt very safe.
“We never really thought this would happen in our school,” she said.
Student Mason Peters told KCAL-TV his class heard a “distinctive sound” outside.
“And so my teacher quickly sprang to his feet, got up, locked the door, asking the students to get the keys,” he said.  And we all just like stayed hidden.” (AP)


Ride your music with 3 people. Collect the blocks matching the colour of your ship/thrusters. Continue to collect your own colour blocks to keep the combo going!


Research and analysis
Investigation of the views of children and young people with speech, language and communication needs (SLCN) about their outcomes.
Ref: DFE-RR247-BCRP12 PDF , 1.51MB , 95 pages
This report presents the findings of 5 projects that were part of the Better Communication research programme.
The report includes:
The findings look at the implications for:
The Better Communication research programme was part of a review of services for children and young people with SLCN .
Published: 27 December 2012


| 1 |
//
|
|
| 2 |
// RouteComposer
|
|
| 3 |
// NavigationDelayInterceptor.swift
|
|
| 4 |
// https://github.com/ekazaev/route-composer
|
|
| 5 |
//
|
|
| 6 |
// Created by Eugene Kazaev in 2018-2022.
|
|
| 7 |
// Distributed under the MIT license.
|
|
| 8 |
//
|
|
| 9 |
// Become a sponsor:
|
|
| 10 |
// https://github.com/sponsors/ekazaev
|
|
| 11 |
//
|
|
| 12 |
|
|
| 13 |
import Foundation
|
|
| 14 |
import UIKit
|
|
| 15 |
|
|
| 16 |
/// `NavigationDelayingInterceptor` delays the router from starting the navigation, while any view controllers in the
|
|
| 17 |
/// stack are being presented or dismissed. In case your app has some other navigation instruments rather than
|
|
| 18 |
/// `RouteComposer` or you have a situation when a few routers work simultaneously, add it to your **router** to avoid
|
|
| 19 |
/// the router not being able to navigate to the destination because a view controller in the stack is
|
|
| 20 |
/// being presented or dismissed.
|
|
| 21 |
///
|
|
| 22 |
/// *NB: `UIKit` does not allow simultaneous changes in `UIViewController` stack. The `.wait` strategy does not
|
|
| 23 |
/// guarantee 100% protection from all possible situations. The code must be written in a way that avoids such
|
|
| 24 |
/// situations. The `.wait` strategy can be used only as a temporary solution.*
|
|
| 25 |
public struct NavigationDelayingInterceptor<Context>: RoutingInterceptor {
|
|
| 26 |
|
|
| 27 |
// MARK: Internal entities
|
|
| 28 |
|
|
| 29 |
/// The strategy to be used by `NavigationDelayingInterceptor`
|
|
| 30 |
///
|
|
| 31 |
/// - wait: Wait while some `UIViewController` is being presented or dismissed.
|
|
| 32 |
/// - abort: Abort tha navigation if some `UIViewController` is being presented or dismissed.
|
|
| 33 |
public enum Strategy {
|
|
| 34 |
|
|
| 35 |
/// Abort tha navigation if some `UIViewController` is being presented or dismissed.
|
|
| 36 |
case abort
|
|
| 37 |
|
|
| 38 |
/// Wait while some `UIViewController` is being presented or dismissed.
|
|
| 39 |
case wait
|
|
| 40 |
|
|
| 41 |
}
|
|
| 42 |
|
|
| 43 |
// MARK: Properties
|
|
| 44 |
|
|
| 45 |
/// `WindowProvider` instance.
|
|
| 46 |
public let windowProvider: WindowProvider
|
|
| 47 |
|
|
| 48 |
/// `Logger` instance.
|
|
| 49 |
public let logger: Logger?
|
|
| 50 |
|
|
| 51 |
/// Type of `Strategy`.
|
|
| 52 |
public let strategy: Strategy
|
|
| 53 |
|
|
| 54 |
// MARK: Methods
|
|
| 55 |
|
|
| 56 |
/// Constructor
|
|
| 57 |
///
|
|
| 58 |
/// - Parameters:
|
|
| 59 |
/// - windowProvider: `WindowProvider` instance.
|
|
| 60 |
/// - strategy: Type of `Strategy` to be used.
|
|
| 61 |
/// - logger: `Logger` instance.
|
|
| 62 |
public init(windowProvider: WindowProvider = RouteComposerDefaults.shared.windowProvider,
|
|
| 63 |
strategy: Strategy = .abort,
|
|
| 64 |
logger: Logger? = RouteComposerDefaults.shared.logger) {
|
14x |
| 65 |
self.windowProvider = windowProvider
|
14x |
| 66 |
self.logger = logger
|
14x |
| 67 |
self.strategy = strategy
|
14x |
| 68 |
}
|
14x |
| 69 |
|
|
| 70 |
public func perform(with context: Context, completion: @escaping (RoutingResult) -> Void) {
|
105x |
| 71 |
guard let topmostViewController = getTopmostViewController(),
|
105x |
| 72 |
topmostViewController.isBeingDismissed || topmostViewController.isBeingPresented else {
|
105x |
| 73 |
completion(.success)
|
100x |
| 74 |
return
|
100x |
| 75 |
}
|
100x |
| 76 |
guard strategy == .wait else {
|
5x |
| 77 |
completion(.failure(RoutingError.compositionFailed(.init("\(topmostViewController) is changing its state. Navigation has been aborted."))))
|
1x |
| 78 |
return
|
1x |
| 79 |
}
|
4x |
| 80 |
|
4x |
| 81 |
logger?.log(.info("\(topmostViewController) is changing its state. Navigation has been postponed."))
|
4x |
| 82 |
let deadline = DispatchTime.now() + .milliseconds(100)
|
4x |
| 83 |
DispatchQueue.main.asyncAfter(deadline: deadline) {
|
4x |
| 84 |
self.perform(with: context, completion: completion)
|
4x |
| 85 |
}
|
4x |
| 86 |
}
|
4x |
| 87 |
|
|
| 88 |
private func getTopmostViewController() -> UIViewController? {
|
105x |
| 89 |
var topmostViewController = windowProvider.window?.rootViewController
|
105x |
| 90 |
|
105x |
| 91 |
while let presentedViewController = topmostViewController?.presentedViewController {
|
105x |
| 92 |
topmostViewController = presentedViewController
|
41x |
| 93 |
}
|
105x |
| 94 |
|
105x |
| 95 |
return topmostViewController
|
105x |
| 96 |
}
|
105x |
| 97 |
|
|
| 98 |
}
|
|


Your first name is required.
Your first name is required to be at least 1 character.
Your first name cannot be longer than 50 characters.
Your last name is required.
Your last name is required to be at least 1 character.
Your last name cannot be longer than 50 characters.
Your e-mail is required.
Your e-mail is invalid.
Your e-mail is required to be at least 5 characters.
Your e-mail cannot be longer than 100 characters.


Constants are global variables that contain system information -- such as os or screen dimensions -- that is sometimes advantageous to know at run time.
The file separator that a system uses. On Windows this will be
\
and on Linux and Mac it will be /
.
Type: String
Example:
print("This system uses '" + FILE_SEP + "' as a file separator.");
Output:
This system uses '/' as a file separator.
The height of the screen measured in pixels. Note that with multiple screens this may only apply to the main monitor.
Type: int
Example:
print("This screen is " + SCREEN_HEIGHT + "px tall.");
Output:
This screen is 768px tall.
The width of the screen measured in pixels. Note that with multiple screens this may only apply to the main monitor.
Type: int
Example:
print("This screen is " + SCREEN_WIDTH + "px wide.");
Output:
This screen is 1366px wide.
The operating system in use.
Type: String
Example:
print("Running OS: " + SYSTEM_OS);
Output:
Running OS: Linux
The path to the user's home directory.
Type: String
Example:
print("User's home directory: " + USER_HOME_DIR);
Output:
User's home directory: /home/john
Note that on *nix systems running this as root, even when logged in as a different user, will yield a different result.
If you run your program with sudo
the output will
look like this:
User's home directory: /root
The path to the temporary directory on the system.
Type: String
Example:
print("Temp directory: " + TEMP_DIR);
Output:
Temp directory: /tmp
The current user's user name.
Type: String
Example:
print("User name: " + USER_NAME);
Output:
User name: john
Note that on *nix systems running this as root, even when logged in as a different user, will yield a different result.
If you run your program with sudo
the output will
look like this:
User name: root
The directory the program is being run from.


{% extends "layout.html" %} {% block content %}
Hi! While I'm not a Therapist, I'm an AI that talks and responds like one.
What's on your mind?


User List
Id
Username
User registration date
User Roles
View
Edit
Delete
View
Edit
Delete
Create New User


This page hasn't been updated in about 4 years, but it still gets tons of hits, so I leave it up. I'm not sure how people keep finding it, but I'm glad they do.
I would encourage you all to
buy the Tao of Pooh
by Benjamin Hoff, as it is a truly great book. It inspired me at a time
when I really needed inspiration, and I suspect it has done that for many
people.
"What's for breakfast? said Pooh. "What do you say, Piglet?"
"I say, I wonder what's going to happen exciting today?" said Piglet.
Pooh nodded thoughtfully.
"It's the same thing," he said.
"Not that many listen though."
"That's the problem."Quotes
"When you wake up in the morning, Pooh," said Piglet at last,
"what's the first thing you say to yourself?"
Through working in harmony with life's circumstances,
Taoist understanding changes what others may percieve as negative into
something positive.
When you discard arrogance, complexity, and a few other things that
get in the way, sooner or later you will discover that simple, childlike, and
mysterious secret known to those of the Uncarved Block: Life is Fun.
The wise are not learned; the learned are not wise
A well-frog cannot imagine the ocean, nor can a summer insect
conceive of ice. How then can a scholar understand the Tao? He is
restricted by his own learning.
"Lots of people talk to animals," said Pooh.
You'd be surprised how many people violate this simple principle
every day of their lives and try to fit square pegs into round holes,
ignoring the clear reality that Thinsg Are As They Are.
Everything has its own place and function. That applies to people,
although many don't seem to realize it, stuck as they are in the wrong job,
the wrong marriage, or the wrong house. When you know and respect your
Inner Nature, you know where you belong. You also know where you don't
belong.


This quick example will show you how to add an array to your JSON tree.
JSONNode n(JSON_NODE); n.push_back(JSONNode("RootA", "Hello World")); JSONNode c(JSON_ARRAY); c.set_name("ArrayOfNumbers"); c.push_back(JSONNode("", 16)); c.push_back(JSONNode("", 42)); c.push_back(JSONNode("", 128)); n.push_back(c); std::string jc = n.write_formatted(); std::cout << jc << std::endl;
The result will look like this:
{ "RootA" : "Hello World", "ArrayOfNumbers" : [ 16, 42, 128 ] }
The first line generates a new root node for us to work with. This node will contain the entire JSON structure we want to create. Because this is created on the stack, there is no need to clean it up, it will do that when it goes out of scope.
Line 2 creates a new JSON_STRING node, i.e. a node that will have a string value, and attaches the new node to the end of our original root node n.
Line 3 creates a new child node and this time we're declaring a type of JSON_ARRAY that states the node will contain a number of nameless children nodes. While it's possible to have different data types in the same array, you should keep them all the same and treat it as if it were a typed array. Note that you can have an array of JSON_NODE objects, so you're not limited to simple data types, just be aware that the array will ignore any node names if you have them set.
Lines 5 through 7 add values to the array, in this case they're all integer values. Because a JSON array cannot contain named values, the name parameter is set to "".
Line 8 appends the array to our root node.
9 and 10 retrieve the formatted JSON string and dump it to stdout.


Graham Dunning uses TidalCycles alongside his Mechanical Techno contraption in an unconventional hybrid performance, which allows room for error, inconsistency and play. The performance highlights similarities in visual and sonic presentation between the two different approaches.
Live cinema coding, experimental music and motion typographics of the code edited live. Cinemato-graphic and sound collage of unfinished expressions of the idea of the future in Mexico City. The project is created with the algorithmic possibilities of TidalCycles and Processing, the premiere of this live act took place in the last edition of Mutek Montreal 2018.
The Cybernetic Orchestra is a participatory live coding ensemble that employs a shifting and heterogenous mix of languages and configurations to make music. Multi-linguality and collaborative interfaces and practices have become definitional for the group. For ICLC 2019 we propose a double roulette in which orchestra members will take turns modifying either notations that produce music or notations that produce generative visuals in conjunction with that music. Our performance will use the Estuary web-based platform, and showcase new and developing features of that platform, including but not limited to: the Punctual language for live coding synthesis graphs, new notations for generative visuals, graphical interfaces that blur the line between text programming and GUI-style interaction, responsive and assistive displays, etc.
Safeguard is an autonomous live-coded performance. The performer is a machine learning algorithm, Cibo, trained to perform (read, change, execute, and repeat) Tidal code. Cibo was trained on sequences of Tidal code, in this way, the implementation of the algorithm has no knowledge of sound. This separation of code and sound resulted in a trained algorithm that recognizes how a human performer would change their code from the human’s perception of sound. Even at this early stage of development several intriguing personified occurrences have cropped up. Further details, implementation methods, and philosophical musings of this research are in our paper submission. We gratefully acknowledge the support of NVIDIA Corporation with the donation of the Titan Xp GPU used for this research.
Street Code is a series of performances of live coded electroacoustic music in public, half public, and/or open
space. It is about taking electroacoustic music from its usual venues and bringing it to unexpected places where
it can enter in dialogue with the city space, both physical and social, and with the architecture of the city.
Finding nice spots to play where the sound could be interesting, and the projection of the codes painting the
walls with musical scores of light created on the fly is what Street Code is all about.
Street Code is a performance for one or many live coders, for a stage, for a tree, for a street, for an alley,
park, or subway station. With a huge sound system or a small usb speaker and for any duration of time.
An Audio-Visual Live Coding Performance Combining Choreographic Thinking and Algorithmic Improvisation.
This piece choreographs the movements in graphic and sound design carried out by human and non-human performers interacting
on themes of hybridity, circulation, and the permeability of language. By adding software agents, the piece expands a
previous composition for two improvising performers, one live coding a browser window and another live coding audio, which
used the circle as a base choreographic concept for how we perceive relationships between users, software agents, the
computing environment, and society at large. We also extended a shared vocabulary to include these concepts and have
moved from strictly dynamic percussive sounds and vocal that evoke sensations of vibration, rhythm, fast movement to
include fluid-like sounds and images, harmony, gradients, mixed non-linear horizontal and vertical arrangements, and
other related elements.
The length of the performance has been extended from the originally presented at the International Live Interfaces
Conference 2018 [1]; and will be excerpted to match the constraints of this conference.
A performance that extends the live coding act to outside of the software IDE, by integrating real time assembly and manipulation of electronic circuits to the traditional “show us your screen” code display, while live coding Arduino boards and physically manipulating speakers. squareFuck unveils a process of failure. The inability to perform a task is, ultimately, the unwillingness to leave things behind.
The CKalcuƛator is a lambda-calculus arithmetic calculator for the piano. It is the fourth sub-system of the CodeKlavier
project whose goal is to become a domain specific programming language that enables a pianist to live code by playing
the piano (Veinberg and Ignacio 2018).
In this performance, duo Off<>zz - Felipe Ignacio Noriega (live coding) and Anne Veinberg (piano), will give a performance
in their standard formation of live coding in SuperCollider and piano playing but with the adjustment of Veinberg using
the CKalcuƛator system and thus composing and evaluating simple arithmetic operations and number comparisons with her
piano playing. The results of these operations are broadcast via OSC, enabling the laptop to utilize them as a
combination of number values, boolean switches, audio input and conditions for the live coded algorithms.
Typing is one the main physical skills involved in text-based livecoding. The ‘classical’ interface for this is the
‘qwerty’-keyboard for 10 finger blind typing. In search for an alternative interface allowing to get away from the
laptop, but still code via a text interface, I came across the commercial Twiddler one-handed (twelve-button) keyboard.
To learn how to use it, I needed practice materials to study the chording for writing code and created an interface that
allows for playback of recorded livecoding scripts, which I then need to type and execute line by line. The interface
is available at https://github.com/sensestage/SuperColliderTwiddler.
At this ICLC, I will perform from a script of RedFrik’s performance “Livecoded supercollider, well practiced” at the
LOSS Livecode Festival in Sheffield on July 20th, 2007, as found on Fredrik Olofsson’s website
(https://www.fredrikolofsson.com/f0blog/?q=node/155). To make the script suitable for performance in 2019 within the
etude-environment, minor adjustments were made in the code to ensure that it would execute and to reduce the line
length to fit into the graphical interface.
Moving Patterns is a duet for dancer and coder. It allows a visual score for the dancer to be created in real time through the Haskell based live coding language TidalCycles and special image language DanceDirt. The audience sees the performers react and change to the score as it develops through coding and movement on stage.
Scorpion Mouse is a duo that explores how algorithmic music and a live vocalist can have a symbiotic relationship and
improvise together. May improvises over the music livecoded by Jason. Jason gets his phrasing cues, dynamics, and transitions
from May’s singing. Similarly, information from Jason’s livecoding system is sent to May’s digital voice processor so that
rhythmic and harmonic effects are in time and in key with the livecoded music, while the amplitude May’s voice affects the
amplitude and filtering of the livecoded beats so that there is space while she is singing, and so the beats are full force
when she is not. In this way Scorpion Mouse are free to explore vast musical territories while maintaining organic unity.
Musically, Scorpion Mouse has influences from electronic styles like trance, drum and bass, IDM, and ambient as well as
influences from electric styles like jazz, soul, rock and pop. Their music is built from three layers: On the bottom, rhythmically
complex percussive beats. In the middle, lush synth harmonies, and on top, ethereal melodic vocals.
Transit is an audiovisual work for live coding. Transit explores computer and cultural processes, which are created and destroyed from their definition, in words or codes, and are transformed in time, by their diverse interactions. The work is inspired, in particular, in Lakutaia Lekipa ́s life, known as the last woman carrier of the Yaganes language and traditions, pre-Hispanic culture of the extreme south of Chile and Argentina. Thus, in a poetic exercise, the writings codes carry messages for the execution in real time of the sounds and graphics that build the multimedia sequences.
SuperContinent is an intercontinental live coding ensemble, with one member per continent. The ensemble rehearses online, via the evolving Estuary platform for collaborative live coding, bringing together artists of quite different sensibilities and exposing the distinctive requirements of live coding ensembles that are highly and definitionally geographically distributed. Our ICLC 2019 performance will bring together the live coding of patterns, the live coding of synthesis graphs (via the new Punctual language for live coding), and the live coding of generative visuals.
The access to crowdsourced digital sound content is becoming a valuable resource for music creation and particularly music performance. However, finding and retrieving relevant sounds in performance leads to challenges, such as finding suitable sounds in real time and using them in a meaningful musical way. These challenges can be approached using music information retrieval (MIR) techniques. In this session, the self-built system MIRLC (Music Information Retrieval Live Coding), a SuperCollider extension, will be used to access audio content from the online Creative Commons (CC) sound database Freesound. The use of high-level MIR methods is possible (e.g., query by pitch or rhythmic cues). This live audio stream of soundscapes from crowdsourced audio material will be combined with a vintage Roland MC-09 used as a drum machine.
This performance will showcase the creative possibilities of Nanc-in-a-Can1, an open source SuperCollider library that we recently developed. Its main focus is the creation and modification of temporal canons (pioneered by Conlon Nancarrow) in a live and interactive setting. We will be exploring the formal and rhythmic aspects of the temporal canon form as well as the application of canonic data to sound synthesis and graphics generation, in order to generate timbral canonic structures that would be “voicing” our pitch based canons, thus generating canons within canons.
...that Enchantress who has thrown her magical spell around the most abstract of Sciences and has grasped it with a
force which few masculine intellects (in our own country at least) could have exerted over it. (Babbage, 1843)
Contemporary Witchcraft is a performance project by Project Group: a multimedia inter-continental feminist performance group.
The performance combines sound, video and movement in a reflection on the interweaving of narratives on programming, women's
bodies and mysticism. The performance is telematic with each performer located on a different continent: in Australia, Spain
and South Korea.
Each performer transmits a different medium which the others respond to, to develop an improvised performance. Knotts live
codes music, Cas uses motion tracking devices to transmit movement data and Bahng interweaves archive video footage with
live video streams of Knotts and Cas performing. Cas and Bahng’s video streams are projected in the performance space
alongside the code interface and audio of Knotts.
Narrative threads on programming, mysticism and digitally mediated embodiment act as stimulus to the improvisation,
freely interwoven, meshed, meeting and diverging. The performance is condensed framework, a meeting of mediatised
cultures, a relation between three mediated bodies distributed in space in a durational awakened process.
iCantuccini plays ‘Greatest Hits’ only! In The Mandelbrots Experience they try to capture and recreate the original
spirit of the live coding boy band Benoît and the Mandelbrots in an unforgettable live show, performing all their
rememberable tunes from The Mandelbrots 2016 Release. Get vegetal with Gurke (Germanfor ‘carrot’) and enjoy the bright
future envisioned in Hello Tomorrow.
Move your bodies to Tranceposition and Tranceportation (which sound awfully alike).
Enjoy the retro-futuristic sounds of Classic or experience a stroll through the Mandelbrots’ hometown with Karlsruhe (‘Charles, remain!’).
On top of the classic sound you’ll get the classic Mandelbrots look, the authentic stage outfits and the same visuals backdrop
behind the code projection The Mandelbrots used without a change since 2012.
As iCantuccini cannot perform their full show at ICLC they will play a medley of the audience’s two favorite tracks.
Select your favorites until under this URL and listen to the live coded recreation by the first Mandelbrots cover band
ever (voting closes 5 minutes before the show).
I propose a performance using extended TidalCycles techniques to create warped, breakneck rave-inspired electronic music.
Our band is called Kolmogorov Toolbox, named after a soviet mathematician who had remarkable contributions to information theory and computation complexity. We are two enthusiastic computer science engineers and musicians from Hungary. We create algorithmic and generative music, primarily through live coding. During our sessions, we use FoxDot to generate music, and Troop to work on it simultaneously. The act is pure improvisation, not relying on any pre-written code.
In this performance, I try to unite the audio and visual stimulus together.
I wrote 100 kinds of shader (GLSL) animation and put them into the application which builds with openFrameworks. This application selects one
shader animation when detecting the note on the timing of TidalCycles via OSC. So when I perform live coding session with TidalCycles,
this system makes synchronized complex animations automatically in real-time.
One sample, one function – a live-coded, single function demolition of one of the most ubiquitous samples in modern
music. This performance work is both an essay in conceptual minimalism and an attempt at filling the dance floor with
the aid of one wavetable and a little maths.
Entirely created within the context of a single, pure DSP function running at audio rate, the performance
starts with a sawtooth LFO reading from a wavetable filled with the Amen break (represented by $). Through
the course of the performance, the Amen break is gradually unmade into new rhythms, melodic and synthetic
sounds. Working with a single sample at a time, and eschewing recursion and randomness, provides a restrictive
but rewarding creative challenge.
AMEN $ Mother Function had its genesis at the Algorave at ICLC 2016, and a conversation about the large number
of samples used in some performances, as well as the popularity of functional programming in live coding.
It inspired me to pare back, start working with a single sample and a single function, seeing how far these
minimal means could be pushed in creating a musical performance. Since Spring 2017 this work has been performed
at various events across Europe, continuing to evolve each time with new elements and many chance mistakes.
We are a live coding trio, making music and visuals. Our performances are A/V shows will electronic sounds
and video projections. We perform by creating our works live and anew for each performance. Our sounds are
dancey and our graphics are SoCal. Sarah’s visuals are coded with her own Clojurescript-Electron app called
La Habra. She creates patterns and abstract shapes that animate and move to the rhythm. Kate and Melody’s
music is created in the Sonic Pi. They manipulate and layer samples with algorithms to create the soundtrack.
We type and improvise as we go, reacting to each other’s output and the audience’s reactions. In accordance
with the Live Coding Draft Manifesto, we project our code as we go, so the audience can inspect and marvel at
the changes and accumulations.Codie has appeared at LiveCodeNYC Algoraves and other A/V events in New York City.
My program, Oscillare, uses Haskell to livecode TouchDesigner. I performed at the 2017 ICLC in MX, but my system, inputs, and output have changed a lot since then. Oscillare now contains input support for a clock sync with other performers, live pressure sensitive drawing input, and I’m working on adding arduino sensor support. Outputs have expanded from just projections to any DMX setup that the venue provides. Augmented Reality is a topic of interest at this year’s ICLC, and I want to augment reality by adding multiple inputs/outputs all going through a central live-coded hub and moving the visuals away from strict code -> projector.
M4LD1TX 5UD4K4 is an audiovisual algorave session of voodoochild/ based on live-coding sequencing MIDI via
TidalCycles, Text-to-Speech in SuperCollider and audio-reactive visuals developed in Processing and controlled
via OSC.
M4LD1TX 5UD4K4 is a series of real-time compositional exercises based on elements taken from Latin American pop
culture with a retrofuturist look that references synth-pop as a post-apocalyptic folklore, pretending to be
both protest song and dance music at the same time.
In M4LD1TX 5UD4K4 live-coding operates as an exercise of reappropriation, dialogue and update of the memory in
the "now". From the tensions and permanent contradictions between the local and the global, between the
anachronic and the current, the hi and the low fi, etc., the performance leads through code as denaturalized
language to a visual and sound experience that is articulated from the intimate and emotional; the code, digitized,
visible, is considered as another "lyric" layer of the performance, and the live-coding in its displacement is
proposed as a posthuman song.
M4LD1TX 5UD4K4 attempts to juxtapose imaginaries in an exercise of articulation of affective and territorial
memory. This way, to images of flag patterns, the wipala, 8-bit street riots, or the inverted world map, are
added the lyrics and arpeggios of songs of Los Prisioneros, Víctor Jara or Virus as part of a dystopian
iconographic and musical exploration.
The performance for live visuals is live coded with Processing, using the REPL engine to edit on the fly the code and change it without recompiling it, to make the performance live coded without interruptions. The visuals will be based on math formulas, trigonometry, hypercubes, supershapes, and will be synchronized live with the music playing and with the devices of the audience, through a web app and a Node.js server.
I propose to perform the visuals for an algorave session at the conference. I will be performing with Visor, a new live coding environment for creative coding of visuals in live performances. Live coding is performed in the Ruby language and graphical capabilities are provided by Processing. Visor utilises user interfaces to supplement live code to allow for example: manipulation of the program state, or visualisation and interaction with real-time audio reactive techniques. I have been working on Visor as part of my ongoing research into how live coding and VJ practice can be combined.
For ICLC 2019 I propose TectoTexto, a live coding performance with SuperCollider in which I will write and
rewrite rhythmic patterns (Pdef) in order to control the synthesizers (SynthDef) of my instrument library (all
synths are written by me, except the clap synth authored by otophilia). The performance begins writing rhythmic
patterns of percussive sounds and tune notes from the scratch. Occasionally I add previous written patterns which I
select depending on the concert situation.
Besides my synths library I use the SuperCollider class tecnotexto.sc which I have developed based on
requirements and questions coming from my practice of live coding. I am interested in the possibilities of
high and low levels of the programming languages. In the case of high level to perform and interact with code
in a live situation, and in the case of low level the preparation and development of instruments and classes.
For the moment, the class TecnoTexto allows me to call my synths library, test sound and call some objects.
For this Algorave set, Olivia and Alexandra will team up to create an audio visual experience of algorithmic/broken/textural techno. Alexandra plays her music using TidalCycles and connects with Olivia, who makes her visuals with Hydra, a software she wrote herself.
We work collaboratively in a shared text buffer using software called Troop where each member of TYPE constructs portions of music-generating code before interacting with the work one another has left behind. By making and unmaking each other’s code TYPE works both together and against each other in the exploration of sound and rhythms. The Troop software will allow us to perform over the internet with two performers connecting remotely from the UK.
At algoraves, live code visualists and musicians often do unplanned collaborations. This is a challenge as
there is little opportunity for communication, especially as musicians are generally too focussed on their code
to appreciate the visuals, which are in any case often projected behind them. A running joke is that a visualist
might find themselves approaching a musician to ask, “do you mind if I do visuals for you?”, but a musician does
not think to ask a visualist “do you mind if I make music for you?”.
We will use this performance as a test-bed for closer collaboration, using techniques such as live data sharing
over the OSC protocol, giving visualists access to high-level audio parameters, and displaying the live coded
video on the live coding musician’s screen, behind their code. The aim is to achieve the feeling that the
visualist and musicians are following each other, in a balanced performance.
Roosa Poni is a collaboration between vocalist Delia Fano Yela and sound artist Alo Allik. This improvised audiovisual performance explores the connection between different vocal styles and live coding in an algorave context. Delia’s vocals ranging from funk and soul to raw laments are processed and woven into the fabric of live coded drones and rhythms of noisefunk. Noisefunk is a musical style that is derived from analysis of traditional rhythm patterns that have been stripped down to their most essential skeletal structures and different patterns are juxtaposed during performances to create long complex cycles and unpredictable syncopation while still maintaining a clearly discernible downbeat in order to undermine the dominance 4/4 time signature of electronic dance music. The sonic material for these rhythm patterns is developed with evolutionary algorithms that evolve complex synthesis graphs. The live input is processed with the aid of machine listening processes to follow tonal, temporal and spectral characteristics of the voice and use this information to control synthesis parameters. The generative visuals, based on artificial life algorithms, are also affected by live audio analysis.
This algorave performance will demonstrate a new and experimental Haskell library for mixing between short
TidalCycles compositions that have emerged from several hack-pacts. A hack-pact is a Live Coding practice in which a
group of participating members hold each other accountable for producing something with code on a regular basis. Often
hack-pacts produce rich libraries of pithy (30s-90s) mini-compositions that briefly explore one musical or theatrical
idea. The TidalStems Haskell module provides an interface to both archive and recall Tidal compositions such as those
generated from a hack-pact. A Tidal composition can be encoded according to the TidalStems type structure as an
indeterminate list of musical ‘phrases’, where each phrase consists of a list of ‘stems’ (borrowing the term from
music production). A stem is represented as a tuple correlating a descriptive category for the stem (such as Drums,
Melody, Chords, Bass, etcetera) with a Tidal pattern. The TidalStems library provides accessor functions to play a
particular phrase or stem from a Tidal composition, offering an easy interface for quickly mixing between Tidal
compositions. For instance, to play the bass line of the 3rd phrase of an archived Tidal composition, the performer
could enter:
d1 $ getStem “my-song” 3 Bass
While the archived compositions are pre-programmed, the performer improvises their curation of compositions,
phrases, and stems, and explores new combinations of the components of different musical ideas. Furthermore,
pre-programmed compositions can be altered by combining them with additional Tidal patterns (such as through
use of the Tidal “#”, “|*|”, and “|+|” operators).
The algorave set will focus on a mixture of acid techno, breakcore and noise music. I will be using a live coding library that I have been developing and testing in algoraves over the past few years. The library is built within SuperCollider, and offers tools to build malleable music that stretches across different time variations, with a meta-sequencer that sequences tempo and time signatures. The library also features modular style continuous sequencing methods, using combinations of pulse waveforms at varying frequencies, phases and offsets to build up patterns. I use a QuNeo controller to record and map control sequences during performance. If circumstances permit, I will also bring a newly developed feedback instrument that is designed to act as a non-linear controller for sound synthesis parameters, which can be integrated into a live coding environment.
We propose an Algorave performance where the aesthetics of fiesta sonidera and from-scratch livecoding will collide.From guaracha cumbiambera to 3D primitives, tropical hardcore, and video-memes, the audience will experience a mixing of sound/video manipulated through both sampling and synthesis techniques. The tool to achieve this is Orbit 1, an OpenFrameworks/SuperCollider live coding tool, recently developed by the RGGTRN member Emilio Ocelotl. The aim of this performance is to achieve a comprehensive aesthetic where the sound is not separated from the visuals and vice versa.
A live coding performance, from scratch, using INSTRUMENT, a library developed by myself, integrated with two other libraries for Supercollider (CaosPercLib + nanc-in-a-can) developed by music hackers from the Mexican comunity. The intent behind these two livecoding tools is to provide a musical way of approaching coding without leaving the SuperCollider environment, which allows a musician to work with synthesis and musical language in parallel. Rhythm, harmony, timbre, and melody are the four musical realms that would normally require a big effort to combine. Thanks to these technologies, a musician is able to compose live electronic music on the fly, with all resources available at your fingertips.
In this algorave performance, I plan to perform with at least four conductor agents. In previous performances, I have only used one or two conductors. This will be my first public performance with more than two conductors, which should make for a frenetic sound, but hopefully one that is still organized and interesting. Previously, the conductors have affected which voices are playing and modified one of the rhythm patterns. In this performance, I intend to use additional conductors to create variations of the current sample set, change sample sets entirely, change density levels, change the type of density pattern, or other aspects of the system. This is part of ongoing research which I am preparing for a paper describing the agent system which I use to carry out my performances. Based on this performance and those to take place shortly after, I hope to gather enough experience and feedback from experts to be able to bring that research into publishable form.
Surface Tension II is a live coding performance by codepage (Tina Mariane Krogh Madsen and Malte Steiner) taking its departure point in the artists own field recorded samples of water. The composition is created through analyzing different material aspects of water using these data both concretely and conceptually, as a vital material. The piece is live coded in TidalCycles, where each sample used is created uniquely for this performance. Through the use of a multi-channel set-up the goal is to create an immersive and dynamic listening experience and in this way create sonic as well as environmental awareness. Additionally the performance will explore the collaborative and experimental potentials of live coding.
This performance will be one of the first to use a new revision of Gibber, in which almost the entirety of the environment
was rewritten from scratch. One advantage of this new version is that audio now runs in its own thread, which enables
greater use of dynamic annotations and visualizations to display the state / progression of running algorithms. Additionally,
new “virtual analog” filters provide better sound quality when compared to previous iterations, along with many other sonic
improvements.
The performance itself cycles through a few different phases over its duration, beginning with algorithmically manipulating
a simple yet aggressive arpeggiated bass, transitioning to a of an ambient phase, and concluding with a barrage of percussion,
noise samples, and glitch effects.
LiveSpoken : Cyphering Thru Livecoding is a presentation and performance of how live-coding can transcend the screen. Combining it with the improvisational nature of the cypher, commonly seen in the hip-hop community. In this performance, not only will the code be improvised in sonic pi but the song writing and vocal elements will also be improvised so the audience can witness some of the stages that goes into a freestyle session.
Alba G. Corral (b. 1977 – Madrid) based in Barcelona is a Visual Artist and creative coder based in Barcelona. With a background in computer engineering, Corral has been creating generative art using software and coding for the past decade. Her practice spans across live performance, video, digital media and installation, exploring abstract narratives and expressing sensitivity and taste for colour. By combining generative systems with improvised drawing techniques, her digital language becomes organic, creating mesmerising digital landscapes. Corral is known for her stunning live audio-visual performances where she integrates real-time coding and drawing in collaboration with musicians. Her works has been exhibited at festivals and events in Europe, México, Japan & EEUU.
Dr Sam Aaron is a Research Associate at the University of Cambridge Computer Laboratory. He is a live coder, who strongly believes in the importance of emphasising, exploring and celebrating creativity within all aspects of programming. Having worked on a number of widely used open-source platforms and tools for creative coding, Sam’s most recent creation is Sonic Pi, a music live coding environment used to teach programming within schools. Sam has taken inspiration not only from his familiar territories of computer industry and academia but also from the arts, a combination he now believes to be essential for the development of well-researched, creative, innovative and practical ideas in this field.


The Dynamic Data Layer
A real-time data collection system that speaks your business Language. Impact and analyse customer journey's, make real connections.
{{ with .Site.GetPage "/talk-to-an-ceddl-expert" }}
TALK TO AN EXPERT
{{ end }}


Our problem
- Virtualising services = many instances
- Many workstations (Ubuntu & Windows)
- Starting to care about BCP
What is Puppet?
- Configuration manager
- State-based
- Agent-master or masterless
How we use it
Backups
node 'thor' {
$backup_dirs = [ '/usr/local', '/var/local' ]
duplicity { $backup_dirs:
bucket => 'test-backup',
dest_id => 'someid',
dest_key => 'somekey'
}
}
'duplicity' module available at https://github.com/Jimdo/puppet-duplicity
How we use it
SSH key management
node /^server/ {
include ssh::server
}
node /^client/ {
include ssh::client
}
node 'abitofboth' {
include ssh
}
'ssh' module available at https://github.com/saz/puppet-ssh
How we use it
Workstation package management
node /^workstation/ {
include workstation
include workstation::developer
}
class workstation( $apt_packages = [ 'thunderbird', 'enigmail' ] ){
apt::source { 'canonical_partner':
location => 'http://archive.canonical.com/ubuntu',
repos => 'partner',
include_src => true
}
-> package{ $apt_packages:
ensure => present,
}
include workstation::packages::oraclejava
...
'workstation' module available at https://github.com/NMiUK/puppet-workstation
How we use it
Installing/managing Oracle Java
class workstation::packages::oraclejava( $ensure = 'present' ) {
if $operatingsystem == 'Ubuntu'{
apt::ppa { 'ppa:webupd8team/java': }
exec { 'accept_java7_license':
command => "echo debconf shared/accepted-oracle-license-v1-1 select true | sudo debconf-set-selections && echo debconf shared/accepted-oracle-license-v1-1 seen true | sudo debconf-set-selections",
path => "/usr/bin/:/bin/",
}
package {'oracle-java7-installer':
ensure => $ensure,
}
Apt::Ppa['ppa:webupd8team/java'] -> Exec['accept_java7_license'] -> Package['oracle-java7-installer'] -> Package['oracle-java7-set-default']
}
}
Caveats
- Manage Puppet with Puppet only if you like playing with fire, naked
- Use librarian-puppet to manage module versions
- Use Hiera
- Use Rspec-puppet for tests
- Don't trust the node name
Fin
Ryan Brooks / www.ryanbrooks.co.uk


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 41. PL/Perl - Perl Procedural Language | Next |
To create a function in the PL/Perl language, use the standard CREATE FUNCTION syntax:
CREATE FUNCTION funcname (argument-types) RETURNS return-type AS $$ # PL/Perl function body $$ LANGUAGE plperl;
The body of the function is ordinary Perl code. In fact, the PL/Perl glue code wraps it inside a Perl subroutine. A PL/Perl function is called in a scalar context, so it can't return a list. You can return non-scalar values (arrays, records, and sets) by returning a reference, as discussed below.
PL/Perl also supports anonymous code blocks called with the DO statement:
DO $$ # PL/Perl code $$ LANGUAGE plperl;
An anonymous code block receives no arguments, and whatever value it might return is discarded. Otherwise it behaves just like a function.
Note: The use of named nested subroutines is dangerous in Perl, especially if they refer to lexical variables in the enclosing scope. Because a PL/Perl function is wrapped in a subroutine, any named subroutine you place inside one will be nested. In general, it is far safer to create anonymous subroutines which you call via a coderef. For more information, see the entries for Variable "%s" will not stay shared and Variable "%s" is not available in the perldiag man page, or search the Internet for "perl nested named subroutine".
The syntax of the CREATE FUNCTION command requires the function body to be written as a string constant. It is usually most convenient to use dollar quoting (see Section <IP_ADDRESS>) for the string constant. If you choose to use escape string syntax E'', you must double any single quote marks (') and backslashes (\) used in the body of the function (see Section <IP_ADDRESS>).
Arguments and results are handled as in any other Perl subroutine: arguments are passed in @_, and a result value is returned with return or as the last expression evaluated in the function.
For example, a function returning the greater of two integer values could be defined as:
CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$ if ($_[0] > $_[1]) { return $_[0]; } return $_[1]; $$ LANGUAGE plperl;
If an SQL null value is passed to a function,
the argument value will appear as "undefined" in Perl. The
above function definition will not behave very nicely with null
inputs (in fact, it will act as though they are zeroes). We could
add STRICT to the function definition to make
PostgreSQL do something more reasonable:
if a null value is passed, the function will not be called at all,
but will just return a null result automatically. Alternatively,
we could check for undefined inputs in the function body. For
example, suppose that we wanted perl_max
with
one null and one nonnull argument to return the nonnull argument,
rather than a null value:
CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$ my ($x, $y) = @_; if (not defined $x) { return undef if not defined $y; return $y; } return $x if not defined $y; return $x if $x > $y; return $y; $$ LANGUAGE plperl;
As shown above, to return an SQL null value from a PL/Perl function, return an undefined value. This can be done whether the function is strict or not.
Anything in a function argument that is not a reference is
a string, which is in the standard PostgreSQL
external text representation for the relevant data type. In the case of
ordinary numeric or text types, Perl will just do the right thing and
the programmer will normally not have to worry about it. However, in
other cases the argument will need to be converted into a form that is
more usable in Perl. For example, the decode_bytea
function can be used to convert an argument of
type bytea into unescaped binary.
Similarly, values passed back to PostgreSQL
must be in the external text representation format. For example, the
encode_bytea
function can be used to
escape binary data for a return value of type bytea.
Perl can return PostgreSQL arrays as references to Perl arrays. Here is an example:
CREATE OR REPLACE function returns_array() RETURNS text[][] AS $$ return [['a"b','c,d'],['e\\f','g']]; $$ LANGUAGE plperl; select returns_array();
Composite-type arguments are passed to the function as references to hashes. The keys of the hash are the attribute names of the composite type. Here is an example:
CREATE TABLE employee ( name text, basesalary integer, bonus integer ); CREATE FUNCTION empcomp(employee) RETURNS integer AS $$ my ($emp) = @_; return $emp->{basesalary} + $emp->{bonus}; $$ LANGUAGE plperl; SELECT name, empcomp(employee.*) FROM employee;
A PL/Perl function can return a composite-type result using the same approach: return a reference to a hash that has the required attributes. For example:
CREATE TYPE testrowperl AS (f1 integer, f2 text, f3 text); CREATE OR REPLACE FUNCTION perl_row() RETURNS testrowperl AS $$ return {f2 => 'hello', f1 => 1, f3 => 'world'}; $$ LANGUAGE plperl; SELECT * FROM perl_row();
Any columns in the declared result data type that are not present in the hash will be returned as null values.
PL/Perl functions can also return sets of either scalar or
composite types. Usually you'll want to return rows one at a
time, both to speed up startup time and to keep from queueing up
the entire result set in memory. You can do this with
return_next
as illustrated below. Note that
after the last return_next
, you must put
either return or (better) return
undef.
CREATE OR REPLACE FUNCTION perl_set_int(int) RETURNS SETOF INTEGER AS $$ foreach (0..$_[0]) { return_next($_); } return undef; $$ LANGUAGE plperl; SELECT * FROM perl_set_int(5); CREATE OR REPLACE FUNCTION perl_set() RETURNS SETOF testrowperl AS $$ return_next({ f1 => 1, f2 => 'Hello', f3 => 'World' }); return_next({ f1 => 2, f2 => 'Hello', f3 => 'PostgreSQL' }); return_next({ f1 => 3, f2 => 'Hello', f3 => 'PL/Perl' }); return undef; $$ LANGUAGE plperl;
For small result sets, you can return a reference to an array that contains either scalars, references to arrays, or references to hashes for simple types, array types, and composite types, respectively. Here are some simple examples of returning the entire result set as an array reference:
CREATE OR REPLACE FUNCTION perl_set_int(int) RETURNS SETOF INTEGER AS $$ return [0..$_[0]]; $$ LANGUAGE plperl; SELECT * FROM perl_set_int(5); CREATE OR REPLACE FUNCTION perl_set() RETURNS SETOF testrowperl AS $$ return [ { f1 => 1, f2 => 'Hello', f3 => 'World' }, { f1 => 2, f2 => 'Hello', f3 => 'PostgreSQL' }, { f1 => 3, f2 => 'Hello', f3 => 'PL/Perl' } ]; $$ LANGUAGE plperl; SELECT * FROM perl_set();
If you wish to use the strict pragma with your code you have a few options. For temporary global use you can SET plperl.use_strict to true. This will affect subsequent compilations of PL/Perl functions, but not functions already compiled in the current session. For permanent global use you can set plperl.use_strict to true in the postgresql.conf file.
For permanent use in specific functions you can simply put:
use strict;
at the top of the function body.
The feature pragma is also available to use
if your Perl is version 5.10.0 or higher.


The Saturn Overdrive (originally produced by Warn) is a bolt on 0.75:1 overdrive for Jeeps equipped with the Dana 18 transfer case. It bolts on the PTO port on the Dana 18 and it works in all forward and reverse gears. There is a PTO adapter available for the Warn Overdrive that will allow you to bolt a PTO output to the back of the overdrive. Advanced Adapters lists the part, but has never produced it. It can be found used.
Talking with Paul Weitlauf, I realized there were more differences between the overdrives than I originally thought.  On his overdirve, the shift rail comes out the back of the case and on mine the shift rail comes out the front of the case.
I double checked the Advanced Adapters catalog and they show an overdrive with the shift rail coming out the back of the case. I'm not sure if all the new Saturn Overdrives have the shift rail out the back or only the big hole untis. A picture of Paul's overdrive is on the right.
Probably the most frequently asked question about the Warn/Saturn overdrive is, "How do I remove the overdrive?" Here are some instructions on how to remove it.


Thoondil restaurant is designed to depict some features of a tropical rainforest, including plant growth; mist, waterfalls, and figures of rainforest animals. To enhance the theme, some of the animals are animatronic, manufactured by Russells Creative, LLC of Apopka, Florida, formerly UCFab International.Elephants are typically found in a pair consisting of an adult and young. Like most animatronics, these face diners from a raised area off a wall. Tigers are a relatively new addition to Rainforest Cafe, and they are normally found in groups of four, with a male, female, and two cubs.
South Indias 1st live seafood restaurant with the ambience designed for nature lovers. An ideal dining place for families, friends and corporates.
19,2nd Cross Street, CIT Nagar, CIT Nagar East, CIT Nagar, Nandanam, Tamil Nadu 600035
9.00 AM to 10.00 PM
Swiggy
Thoondil provides a good facility of customer service,parking,free wifi etc., Thoondil provides delicious indian,chinese and mexican foods
Get a membership card with us and have a great offer with the upcoming weeks


#include <region.h>
Data Fields | |
| union { | |
| Node * node | |
| L_Cb * cb | |
| } | member |
| region_member * | nextMember |
Definition at line 65 of file region.h.
| L_Cb* region_member::cb |
| union { ... } region_member::member |
Referenced by addRegionMemberCb().
Definition at line 73 of file region.h.
Referenced by AddMember(), addRegionMemberCb(), freeRegion(), and printRegionCbs().


Collaboratively engineer impactful niches for business dramatically crossunit.
Conversion first mover advantage ramen deployment business model canvas beta creative android burness model canvas beta creative android burn rate graphical user. Conversion first mover advantage ramen deployment Conversion first mover advantage ramen deployment business model canvas beta creative android burness model canvas beta creative android burn rate graphical user. Conversion first mover advantag deployment
Conversion first mover advantage ramen deployment business model canvas beta creative android burness model canvass model canvas beta creative android burness model canvas beta creative android burn rate graphical. Conversion first mover advantage ramen deployment
Conversion first mover advantage ramen deployment brst mover advantage ramen deployment business model canvas beta creative android burness model canvas beta creative android burn rate graphical user. Conversion first mover advantage ramen deployment
Conversion first mover advantage ramen deployment business canvas beta creative android bu onversion first mover advantage ramen deployment business canvas beta creative androon first mover advantage ramen deployment business canvas beta creative android burness model canvas beta creative android burn rate graphical user. Conversion first mover advantage ramen deployment
Conversion first mover advantage ramen deplment brst mover adntage ramen deployment business
Conversion first mover advantage ramen deplment brst mover adntage ramen deployment business
Conversion first mover advantage ramen deplment brst mover adntage ramen deployment business