![]() |
|
![]() |
The DATA EDITOR implements CDP's powerful COLUMNS program, which has around 100 functions to edit, generate and sort (mainly) single columns of data, such as time values or parameter values. There are also file-manipulation facilities for splitting breakpoint files into separate columns, joining them together etc.
CONTENTS
INTRODUCTION
Soundshaper provides several ways of getting data into the DATA EDITOR and exporting the processed files:
- From the Main Page Data menu
- From the Graph-Edit page
- From within the Data Editor itself
Typically, you might export a breakpoint file from the Graph-Edit page to the DATA EDITOR, process either Column 1 or Column 2 and then send the result back to GRAPH-EDIT. Alternatively you can export a single column and process that.
Or you can load data files (breakpoint or single-column) from within the DATA EDITOR and process them many times without leaving the Editor.
The CDP functions called from within the DATA EDITOR process mainly single columns of data, but the editor itself can handle breakpoint files (.brk) or single-column textfiles (.txt, .col, or .tun).
The functions are grouped into various categories: Music, Math, Generate, Random, Sort, Info, Tables and are selected by Menu and by Radio Button. (Some functions could be in more than one category.) Menu items have icons such as
to show the function type.
There are also Function-key shortcuts to speed up Radio-Button selection within the same group of Operations: F1 selects the first item, F2 the second, and so on (see the Operation Menu).
There are broadly five types of function:
- CONVERT
These convert one form of data into another e.g. Midi to Hertz, Multiply values.
- SORT
These re-order or group data in some way: for some functions the output is longer or shorter. Some functions which eliminate data are coded with the icon:![]()
- GENERATE
These generate data e.g. Generate harmonics, Generate accel. times and typically require a start and end value as input.
- INFORMATION
For example: find greatest, sum times. Processing functions such as Midi-Hz or Sample-count to times can also be used as information functions on a column of data.
- TABLE PROCESSING
For example: Files to Columns, Concatenate files. These functions are found in the Tables menu.
The Help Menu has a list of the above Function Types, which also acts as a reference list of the image symbols used on the processing menus. Clicking on one of these menu items displays a short message about the function type.
The COLUMNS functions are not concerned with the appropriateness of the resulting data for any particular purpose: the user must ensure that ranges and values are suitable for the intended parameter.
Note especially:
- Timepoints must be in ascending order, before being graphed or used by CDP processes.
- There should be no blank lines, particularly if the data is to be returned to Graph-Edit.
Some COLUMNS grouping functions create these the Close Gaps button removes them.
DATA FILES
Most datafiles in CDP represent time-varying values in a breakpoint format (.brk), as time & value pairs, where one column stores a series of time-points (X-axis in Graph-Edit) and the other stores the changing values for the parameter concerned (Y-axis in Graph-Edit).
For example:
[time value] 0 0 0.156 56.32 0.489 165.28 0.689 8.64 0.887 68.16 1.000 0.00Some files (.txt) store other pairs of values, such as a filterbank's MIDI-pitch & amplitude:
[pitch amp] 12 2.73 18.97 3.27 35.9 4.9 47.07 5.3 59.1 6.28 72.31 5.37 86.53 6.51 99.23 5.63 108.03 4.37 118.7 4.07Others processes require a single column of values, such as PEAKPULSE (CDP: retime retime 1) which needs a list of timepoints:
0.070794 0.171973 0.985329 1.145828 1.247664 1.395669 1.548345 1.770385 1.824195 2.025556 2.191927 2.31993All of these types can be handled in the DATA EDITOR, where some operations transform only a single column.
GENERAL OPERATION
The main operations of the Data Editor are as follows:
- DATAFILE:
If you have sent a file to the Data Editor from the Main page or the Graph-Edit page, it should be displayed in the MEMO BOX in the centre of the page.
Alternatively, load a datafile using the File Menu, or by DRAG + DROP. The following file types are recognized:
.brk; .env; .pch; .txt; .col; .flt; .tun; .ptr
- The MEMO BOX allows you to edit the data "manually" or create data from scratch.
You will be prompted to Save to file if you appear to have changed data in the Memo.
If you create a table from scratch, Save it (using the SAVE FILE button or the File Menu) and then Open it as the file to be processed (using the OPEN FILE button or the File Menu).
- PROCESS TYPES:
Processing operations are listed in a series of Menus: Music1, Music2, Music3 etc.
Select an operation from one of the sub-menus or simply select the first item, to display up to 12 operations, such as the Music1 list in the above example.
- SELECTING AN OPERATION:
To select from within the current list of operations, either:
- Click an appropriate Radio Button, or
- Scroll down the list using the Up/Down arrow keys on the QWERTY keyboard, or
- Click on a Function key e.g. F8 to select Major to Minor in the above example.
- OPERATION DESCRIPTION:
Selecting an operation brings up an Operation Description in the Information Panel at the bottom of the page.
- PARAMETERS:
Some operations cause one or two Parameter Panels to be displayed.
- Set a parameter value, as on the Parameter Page.
- Click on a Parameter Panel to see the Parameter Description in the Information Panel.
- Click on the OPERATION DESCRIPTION button to return to displaying information about the operation.
- FILE LENGTH:
Different processes give different File-Lengths. A panel above the proposed Outfile name displays indicates whether the processed file is likely to be of the same length (displays =), longer (+), shorter (-) or variable/unknown (?). This is particularly important if you intend to merge the results back into Graph-Edit.
- OUTFILE:
An Outfile name is proposed in the outfile box. You can rename this as you wish.
RUNNING THE PROCESS
- Click on the RUN + Exit button to run the process and return to the Main Page or Graph-Edit as appropriate.
- Alternatively, click on the RUN button to run the process, but remain within the DATA EDITOR.
Then:- Click on the OUT-->INFILE button to display the results and process them further.
- Click on the EXIT button when you have finished processing.
ACTIVE COLUMN
If you have loaded a file of two or more columns and your chosen functionp rocesses only one column (as is mostly the case), you need to choose which column to process. This is done in the Active Column section:
![]()
When a Breakpoint file is loaded, the Active Column is normally set to 2, the &value column, by default. (If not, set it manually using the arrow buttons.) Simply click RUN to process this column and merge the result back into a two-column file, which is saved as the Outfile.
Processing Column 1
You might, however, set the Active Column to 1, for example to process the times column of a breakpoint file.
You would then push buttons in this order:
- GetCol: isolates column 1 as a single column
- RUN: run the process
- PutCol: restore column 2
- (Save the file)
FILE DISPLAY PANEL
The File Display Panel gives information about the file display, plus some control buttons:
![]()
Firstly, the number of lines and columns are shown.
The buttons are:
- Select Folder:
This sets the default folder that the file selector opens when you select a data file.
- Open File:
This opens a file selector within the Data Folder. The current file masks available are:
- .txt Textfiles of no specific type.
- .brk Breakpoint text files.
- .col Single column text files of no specific type. This extension is used by Graph-Edit, particularly the default filename CDP.col which you should avoid saving to. (It may be overwritten without prompting!)
- .tun Single column text files of frequency or MIDI values.
- Save File:
This opens a Save-File dialog. The button duplicates File | Save File As... (Shortcut: Ctrl+A).
There is also File | Save File (Ctrl+S), which overwrites the current file.
- Clear Display: This clears the display and its associated filename. The same Infile may be shown in the In-Out File Panel, however: the file itself is not cleared.
- Close Gaps: This cleans up the display by eliminating any blank lines created by some functions.
Files with blank lines are of no use in CDP processes.
- Show Last InFile: This button allows you to see the data you sent to the process. After you have clicked the Out-->Infile button, use this to compare the results with the original. This is a "toggle" button click it again to show the Outfile data. Note that the new Infile is not affected by this operation.
OUTPUT FILES
The default Outfile folder is the same as the Infile's, but may be changed via the Folder button.
You can also edit the Outfile name.The Outfile file extension is also set by default to the same as the Infile. The other file extensions in the drop-down box are taken from the textfile Textypes.txt which is located in the SOUNDSHAPER\BAT folder. You can edit this to create your own text types which COLUMNS will then recognise.
Clicking RUN or RUN+Exit saves the result to the named Outfile. The resulting file then becomes the new Infile and is displayed in the Memo Box. The Last Infile and Out --> Infile buttons are included to restore the display if you alter it, e.g. by GetCol or Clear, and then change your mind.
EXPORTING FROM GRAPH-EDIT
An important aspect of the DATA EDITOR is as an extension of the Graph-Edit page: you can export a file to the Data Editor, process it and Exit to be returned together with the processed file to Graph-Edit.
On the Graph-Edit page, there is a panel dealing with exporting files or columns in this way:
![]()
To send both columns as a breakpoint file, click the X and Y button under Send.
To export a single column to the Data Editor, set the column number (1 or 2) under Column, then click the 1-Column button under Send.
After processing in the Data Editor, to return the processed values to the graph, you would normally leave the column number as already set (1 or 2). Click on the To Column button under Return. Before doing so, it is advisable to be aware of the lower and upper limits of the processed values and reset the Graph X or Y limits (see Graph Parameters) as necessary.
Apart from the usage description which comes with the CDP COLUMNS program, CDP has no documentation on the individual Columns Functions. The following information has been deduced from the given description and by trying out the functions to see what they do.
In the following examples, a column of values is represented as a string separated by commas, to save space. For example, 10, 20, 30 is equivalent to the column
10 20 30MUSICAL FUNCTIONS
MUSIC 1: Convert Pitches and Intervals
These functions transform pitches, frequencies and intervals in familiar ways.
Midi to Freqs / Freqs to MIDI: Convert MIDI values to Frequencies or vice-versa. MIDI values may be fractional (e.g. 60.43 for Middle C+43 cents).
MIDI to semitones: Produces the intervals between successive MIDI values: 60, 64, 67 becomes 4, 3 - the outfile having one less value than the infile.
Freqs to Ratios: Gives the intervals between successive frequencies as ratios: 440,550,660 becomes 1.25, 1.2 The CDP command is actually just "Ratios" and is duplicated in Math1#8.
Semitones to Ratios: Converts a column of intervals in semitones to intervals as ratios: e.g. 6, 5 becomes 1.414214, 1.334840
Invert MIDI: Mirror inversion beginning from the first value: 47, 53, 58, 62 becomes 47, 41, 36, 32, i.e. +6 becomes -6, then +5 becomes -5 and so on.
Invert Freqs: As invert MIDI but for frequency, inverting frequency ratios: *N becomes /N; e.g. 440, 550, 660 becomes 440, 352, 293.33, i.e. *1.25, *1.2 becomes /1.25, /1.2 or *0.8, *0.833
Major to Minor: You nominate a key in the Parameter Box eg C, C# etc. (ignore the fader) and the 3rd and 6th of the scale are flattened, if present. The reverse function Minor to Major sharpens the 3rd, 6th and flattened-7th of the scale, if present.
Temper MIDI: Data is tempered to an equal-tempered scale of N divisions. This produces no change to integer MIDI values if 12 divisions (the default) are nominated. Cent values within N=12 are rounded, with .5 rounded down. Other temperings are fun to experiment with, but hard to predict, e.g. 47, 53, 58, 62 becomes 46.83, 53.03, 58.06, 61.93 when N=31.
Temper Frequencies: The frequency equivalent of Temper MIDI, based around Middle C. Again, it is based on an equal tempered scale of N divisions.
Quantize over q: The simplest way to understand this is to think of the way a sequencer quantises rhythm by moving the actual onsets to e.g. the nearest 1/16th note (semiquaver). Similarly the MIDI values 47,53,58,62 quantised over 5 become 45, 55, 60, 60 as they are moved to the nearest values in the series 0,5,10,15,...
The formula used seems to be Round(NUM/q)*q. To round numbers, use q=1 (0.5 rounds down).
MUSIC 2: Reorder or generate pitches
These functions change the order of elements in the column or generate new groups based on the input list.
Rank frequencies by vote (number of occurrences): The data need not be frequencies MIDI data works just as well. 60, 62, 62, 64, 64, 64 becomes 64, 62, 60: the ranking by frequency of occurrence is clear, but the elimination of duplicates is strange.
Given a long list of frequencies, perhaps generated from a .frq file, you could quantise these and then apply this function to see which occurred most frequently; or you could study pitches in a TEXTURE notedata file. But as a musical operation, the purpose of the function is not obvious.
Group frequencies as harmonics: Lists frequencies in harmonic groups; frequencies may appear in several groups if they are harmonics of different fundamentals. E.g. 60,70,100,120,140,180,200 produces 60,120,180; 70,140; 100,200. The groups are separated by blank lines.
Motivically rotate list: Cyclic rotation by N shifts; eg. 60, 70, 100, 120, 140, 200 shifted by 4 produces 100, 120, 140, 200, 60, 70 (as each rotation puts the last event first).
Plain Bob 8: A type of motivic permutation used by English bell-ringers: one of many "change-ringing" patterns. The input file must have 8 values and the process generates 103 permutations of these. Avoid pitch-class repeats (MIDI/Freq): NOT WORKING? The list 60, 60, 72, 72, 84, 84 (repeated Cs) returns an identical list, as does a list of frequencies.
Duplicate values at 8ves (MIDI/Freq): Values are repeated 1 or more octaves above the originals - the return list retains the original MIDI/Freq order: 22, 21, 20 over 3 8ves produces 22, 21, 20, 34, 33, 32, 46, 45, 44, 58, 57, 56
Generate Harmonics: The output is not quite what you might expect: zero is added to the list so the actual number of harmonics is one less than you asked for! For example, the single frequency 110 and "number of hmcs" 5 produces 0,110,220,330,440.
Generate Subharmonics: NOT WORKING? It seems to produce a list of zeros.
MUSIC 3: Process Times and Levels
These functions mainly process onset times and durations.
Gain-dB conversions have been added to the group, to complete the music functions.Times from durations: Produces a list of onset times from a list of durations: useful for mixing or producing timepoints for a breakpoint file / graph. 0.1, 0.2, 0.3, 0.4 produces 0.0, 0.1, 0.3, 0.6, 1.0 Same as STACK (Math1/No.11).
Times from beatlengths: The input values are in number of beats; the tempo is number of beats per minute (beat can be any value, not simply 1/4-note). For example 1,1,2 @120BPM produces onset times of 0, 0.5, 1.0 and 1, 0.5, 0.5, 2 @60BPM produces onsets of 0, 1, 1.5, 2.
Note that the onset time following the last note-value is not given (c.f. Times from durations).
Times from beat positions: Onset times @60BPM are beat positions - e.g. 0, 1, 1.5, 2 from above example. At 60BPM the output of this function is identical to the input - use it instead to calculate the effect of tempo change: 0, 1, 1.5, 2 @120BPM is 0, 0.5, 0.75, 1.0.
Whether you prefer to think of a rhythm as a series of notelengths or beat positions is up to you: for example the opening of the Marseillaise is 1 3 1 4 etc. (1=1/16th note [semiquaver] ) the equivalent beat positions (in 1/16th notes) are 0 1 4 5. Onset times from both Times from beatlengths and Times from beat positions are 0, 0.25, 1.0, 1.25 @240BPM (equivalent to 1/4 note=60).
Times with constant density: If you want to maintain a constant note-density (or amplitude, if the sounds are of similar loudness) and are less fussy about their exact onset times, how would you know when to bring them in? This function calculates the onset times for you: for example durations 5,4,3,2,1 produces onsets of 0, 0, 0, 3, 4:
0 1 2 3 4 5 [onset times] x . . . . . x . . . . x . . . x . . x .Sample count to times: Positions in a soundfile can be obtained most accurately as a sample count (number of samples from the start) this converts a list into times in seconds for a given sample rate. There is an equivalent conversion function for individual sample-counts in the INFO section.
Sum times less overlaps: Where sounds are joined sounds end to end with a certain overalap (splice) time, this calculates the resulting overall time from the list of durations: e.g. 5, 4, 3, 2, 1 returns 14.94 for a splice time of 15 msecs (the default).
Sum zigzag times: In the ZIGZAG process (Soundfiles | Extend | Zigzag), you can specify a series of timepoints: from a list of onset times, this function calculates the duration of the outfile, with optional splice overlap. For example, 0, 4, 1, 5, 6, 2 produces 16.0 (4+3+4+1+4), with overlap=0.
Generate accel. times: generates a series of onset times to give an accel. or decel. The Infile has two or optionally three values: 1) The starting gap between onsets 2) The final gap between onsets 3) The start time for the process (default 0 secs). E.g. Infile 1.0, 0.1 over 20 secs produces 0.0, 0.977859, 1.912737, 2.806524...19.788589, 19.896670, 20.000000.
Note that the process does not start with the starting value as the first gap (surprisingly): to achieve this start the process after the first-gap duration (in this case 1.0). Thus, 1.0, 0.1, 1.0 over 20 secs produces 1.000000, 1.977859, 2.912737...etc., to which we can preface 0.000000 as required. Similarly, the final gap above is not 0.1 we really need to stop the accel. at 19.9 seconds and append timepoint 20.000000 to the list.
To generate a deceleration, simply have value 1 shorter than value 2: e.g. 0.1 to 1 over 10 secs produces 0.000000, 0.104513, 0.218599...etc.
This function is particularly useful for creating exponential times in a breakpoint datafile (merge into Graph-Edit) but can be used to generate any data that increases or decreases exponentially over a given range.
Generate accel. durations: This function is particularly useful for generating exponentially changing values in a breakpoint datafile. E.g. Infile 1.0, 0.1 over 10 (secs) produces: 1.000000, 0.956090, 0.873373 ...0.119296, 0.108975, 0.099547 .
dB to Gain / Gain to dB: Decibel values are typically negative from (e.g.) -100 to 0dB, which is full gain. Gain values typically range from (e.g.) 0.00001 (=-100dB) to 1, which is full gain. However, you can have gain values >1 if you are increaing the signal, and equivalent dB values >0: a gain of 2.0 =6dB.
These functions convert a list of values between the two types: eg dB to Gain with Infile -100, -30, 0, 6 produces 0.000010, 0.031623, 1.000000, 1.995262 .
MATHEMATICAL FUNCTIONS
MATH 1 and 2
Many of these functions have an optional threshold parameter, above or below which the function is applied.
Add: Add a constant value (+ or -) to all values in the list.
Multiply: Multiply all values in the list by a constant value. Use a constant <1 to lower values or use the divide function.
Divide: Divide all values in the list by a constant value. Or multiply by a constant <1 to have the same effect.
Approx. Multiples: Approximate (quantise) all values to multiples of the given value. E.g. 221, 442, 663, 884 quantised to 110 produces 220, 440, 660, 880 all multiples (harmonics) of 110.
Power: Raise all values by the given power.
N/val: Multiply all values by N/value; for example N=1 produces reciprocals.
Difference between values: Gives difference (interval) between successive values: e.g. 220, 440, 660 produces 220, 220. MIDI to Semitones (Music1 / No.3) is a specific application of this function.
Ratios between values: Gives ratio between successive values: e.g. 220, 440, 660 produces 2.0, 1.5.
Add N to intervals: Add N (+/-) to the difference between successive values: e.g. 221, 442, 663, 884 with N=10 produces 221, 452, 683, 914, i.e. Value[k]-Value[k-1]+N the first value is not changed, as there is no previous value. Use this function to stretch (or shrink) intervals by a constant amount.
Multiply intervals by N: Multiply the difference between successive values by N: e.g. 220, 440, 660, 880 with N=1.1 produces 220, 462, 704, 946. Here, frequencies are stretched from their harmonic values by 10%. Use this function to stretch (or shrink) intervals by a constant ratio.(c.f. Alter slope).
Stack values from 0: Stacking produces the cumulative total, e.g. 0, 1, 3, 6 stacked = 0, 1, 4, 10. 220, 440, 660, 880 stacks to 0, 220 660, 1320, 2200, as the values are stacked from 0.
The function is used for Times from Durations (Music3, No.1), in which the intervals between timepoints (durations) are used to create a list of times. So this function converts intervals (differences between values) into a list of values that would produce these differences and is the reverse of Differences between values if the original value is added. For example: Difference between 221, 442, 663, 884 is 221, 221, 221. This stacked from 0 is 0, 221, 442, 663. Add the "original" start value of 221 to give 221, 442, 663, 884 the original list. There is an optional overlap parameter, as in Times from Durations.
Sum successive N values: This processes a "window" of N values: e.g. if N=3, the elements summed are 1,2,3 then 2,3,4 then 3,4,5 etc. For example, 1, 2, 3, 4, 5, 6 with N=3 produces 6, 9, 12, 15. Note that processing stops with the last complete group of N. The resulting list can be divided by N to produce a "moving average".
Alter slope: This seems to be identical to Multiply intervals by N, e.g. 220, 440, 660, 880 with N=1.1 produces 220, 462, 704, 946, as in the Multiply intervals example. 6, 9, 12, 15 with a factor of 1.1 produces 6, 9.3, 12.6, 15.9.
Quantise: The function listed under Music1, No.12 is repeated here as it can be classed as a mathematical as well as a musical operation.
Limit intervals to <max: Note that this limits intervals, not values (see below for this). 220, 462, 704, 946 with max 220 produces 220, 440, 660, 880, which in this case scales the values stretched in Alter slope back to the originals. Clearly any interval <=max is passed, anything >max is limited to max.
Limit intervals to >min: Here any interval >min is passed, anything less is raised to min.
Limit vals to <max / Cap values above limit: Here the values must not cross a ceiling: values higher than the ceiling max. are capped at the ceiling value, e.g. 220, 440, 660, 880 with max of 500 produces 220, 440, 500, 500. The two functions seem to be identical. The function could be useful if for example you have processed a list of frequencies but need to limit them for filter functions whose upper limit is 14700Hz (see e.g. Filter Variable).
Limit vals to >min / Raise values below floor: Here all values are raised if they are below a certain threshold: e.g. 220, 440, 660, 880 with min of 500 produces 500, 500, 660, 880. Again, the two functions seem to be identical.
Note that Graph-Edit has a built-in limiter: the adjust all Y checkbox used with the Y value slider raises and lowers values (c.f. Add above) and limits them at the top and bottom of the range.
GENERATIVE FUNCTIONS
These functions complement the generative functions found in the Music group. Some are also available as presets within Graph-Edit.
Generative functions usually have two values for the Infile: a start and an end value.Intermediate values: Substitute intermediate values for those in the list: intermediate values are those half-way between the values in the original list (ie interval/2). E.g. 220, 440, 660, 880 produces 330, 550, 770 (the odd harmonics of 110). Although this function does generate new values, it is really a processing function.
Equal divisions: NOT WORKING? The flag does not seem to be recognised by the COLUMNS program.
The function should produce equal intervals between the start and end values.
N.B. This function is available as a Graph-Edit preset: Set X low to the desired lower limit and X high to the desired upper limit click OK. Click Generate/Equal Points. Export the data to the DATA EDITOR: click the Process button.
The function is also available via Quadratic-curve steps (see below) if the curve is set to 1 (linear).
Log equal divisions: Here, the divisions are times a constant, instead of plus a constant as in Equal Divisions.
Thus 4 divisions between 10, 20 produces 10.000000, 11.892071, 14.142136, 16.817928, 20.000000. The constant multiplier is 1.1892071. Equal-tempered intervals are log-equal divisions of the octave; thus 440, 880 divisions 12 will give you all the semitone frequencies between Concert A and the 8ve above: 440.000000, 466.163762, 493.883301, etc.
You can use this function to generate equal-tempered scales of N values between any two frequencies or MIDI values, or filter frequencies based on equal intervals, e.g. a 100-band filterbank from 20-14700Hz has frequencies at 100 log-equal divisions between 20 and 14700. (c.f. Temper frequencies)
N.B. This function is also available as a Graph-Edit preset: Set X low to the desired lower limit and X high to the desired upper limit click OK. Click Generate/LogEqual Points.
Equal intervals: Here you set the desired interval, rather than the number of divisions. If the interval does not divide equally into the range of values, the final value is the highest available in the range. E.g. 440,880, Interval 50 produces 440,490,540...790, 840.
Quadratic-curve steps: Set the lower and upper limits then the curve (>0): 0-1 for an UP curve increasing intervals, >1 for a DOWN curve decreasing intervals. The parameter sets the number of steps. For example, 0, 100, 2 , steps 4 produces 0.000000, 50.000000, 70.710678, 86.602540, 100.000000. If the curve is 1 (straight line), you will get Equal divisions, e.g. 0,100,1 steps 4 gives 0,25,50,75,100.
Duplicate each value: Each value in the list is duplicated N times, e.g. 0.1, 0.2 produces 0.1, 0.1, 0.2, 0.2 with N=2
Duplicate list: Whole list is duplicated N times.
Repeat intervals: Starting with the last value in the list, the intervals, rather the list values are duplicated. For example: 1,2,5,9 with duplicates 2 produces 1,2,5,9,10,13,17, 18, 21. (Perhaps there should be a final 25 here?)
Applied to MIDI pitch values, you can replicate a chordal or scale pattern upwards, e.g. MIDI 54,56,57 (f#-g#-a) duplicated 4 times gives: 54,56,57,59,60,62,63,65, 66, 68 an octotonic scale.
RANDOM FUNCTIONS
These functions modify values by a random amount or generate random values.
Add Random value + or +/- : Adds a random value (possibly negative) up to the value set in the LIMIT parameter to each value in the list. If used with a list of integers, you will have to round the results, perhaps using the Quantise function.
Multiply by Random value: As add random value, but multiplying by the value. If you set LIMIT to <1 all values will be reduced, but anything higher will randomly increase or reduce values.
Scatter: This function creates variants near the original values, e.g. 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 with a scatter value of 0.5 produced 10.000000, 20.510651, 29.267479, 40.762581, 48.124409, 57.565615, 70.957900, 79.245048, 90.660039, 100.000000.
Randomise order: This re-orders the list randomly. Optionally you can repeat the operation N times; each repetition should produce a different order.
Random chop: Generate intermediate values from 0 to the top of the RANGE parameter, chosen randomly according to the two values in the Infile: min and max. Note that the "normal" practice of putting the range in the Infile and the divisions in the parameter has been inverted here. For example, 1, 3 with a RANGE of 10 generated random numbers from 0 to 10 with a minimum interval of 1 and a maximum of 3: 0.000000, 2.497665, 3.881832, 5.171026, 6.359142, 8.085482, 9.260720.
Generate random 0s and 1s: The Infile gives the number of random binary numbers required. E.g. an Infile of 10 produced 1,1,0,1,1,1,0,0,0,0 with blank lines inbetween, which were eliminated using the Clear Blank Lines button.
Generate random values: The Infile gives the range min and max, the parameter N the number of random values to generate. For example, 40,50 N=4 produced 48.428297, 45.105441, 42.410657, 45.899533. Evidently, the results are not in ascending order.
Eliminate random items: You specify the number to eliminate from the list and these are chosen at random and eliminated.
SORTING FUNCTIONS
These functions re-order the items in the list; some match those listed under MUSIC.
Alphabetic sort: Arranges items in alphabetic order - not clear which CDP process would need this, but of some general use.
Numeric sort: Sorts items into numerical order; handy if you've generated random numbers or grouped items in some way.
Reverse order: Reverse the order, e.g. ascending to descending.
Skip every Nth item / N items : In the first, you specify the number to keep before skipping one, e.g. KEEP 3 skips 1 in every 4. In Skip every N items, this situation is reversed: you keep 1 and skip N, e.g. 1,2,3,4,5,6,7,8,9,10 SKIP 2 produces 1,4,7,10.
Rank by occurrence: see Music 2, No.1.
Regroup list: An example may explain this best: 1,2,3,4,5,6,7,8,9,10 regrouped with N=2 produces odd numbers then evens: 1,3,5,7,9, 2,4,6,8,10 the same with N=3 produces 1,4,7,10, 2,5,8, 3,6,9. This example also illustrates the order in which items would be picked from any list of the same length. Blank lines can be eliminated using the Clear blank lines button.
Eliminate N / vals >N / <N: These three functions are fairly self-explanatory - if the items are in the list, they are removed. Note the difference between eliminating values below a threshold / above a ceiling and limiting them, as seen above in Math-Limit functions.
Eliminate duplicates within range: NOT WORKING? This doesn't seem to do what you might expect: 1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9 Range 1 produces 1,3,5,7,9; this output list, which has no duplicates, processed with range 2 produces 1,5,9.
Eliminate even items does indeed eliminate items 2,4,6, etc. To eliminate odd ones, add one to the top of the list and remove it after processing.
INFORMATION FUNCTIONS
These functions produce information about the items in a list.
Find greatest / least / total / product / mean: A single value is reported the maximum, minimum value in the list, the sum / product / or mean of all values.
Sum absolute differences : See Music3, No.7 Sum zigzag times which uses this function. 1, -2, 3 produces 8: the difference between 1 and -2 is 3, between -2 and 3 is 5; 3+5 is 8.
Sum, minus overlaps: also seen in Music3, No.6 Sum times less overlaps, which is the obvious application. You might use this function to sum durations joined with a splice overlap. E.g.: 1,2,3,4 with 0.1 overlap returns 9.7 sum of 10 less 3 overlaps of 0.1.
Count vals above or below a threshold value: NOT WORKING? This is supposed to count how many values in the column are above or below some threshold value. Seems to produce and empty outfile.
Mark values >N / <N: The list is copied but with the relevant values marked with an asterisk.
Count lines: Soundshaper already does this for you on the DATA EDITOR page just open the file.
MIDI to Text: MIDI values are translated into pitch names such as C1. This sounds like a good idea, but the result is marred by having "INFO" in front of every pitch name, especially as the reverse function Text to MIDI rejects lines beginning with "INFO"! Also Middle C (MIDI 60) is described as C0, which is non-standard, though easy to understand. Fractional MIDI values are translated roughly: 60.5, 60.4, 60.3 all had the suffix (++).
Text to MIDI: Having got rid of the aforementioned "INFO"s, you can retrieve a MIDI list from a textfile of pitch names. You can use this function to translate pitches with more normal octave numberings (there are several systems in existence), provided you are prepared to subtract a suitable value from the result the function is then quite useful! For example, if you number Middle C as octave 4 then C4,E4,G4 translates to 108,112,115; use Add with -48 to remove the 4-octave difference and produce the MIDI-corrected 60,64,67. Fractional values are ignored.
Text to Hz: simlarly produces a list of frequencies from a list of pitch names.
TABLES: MANIPULATE COLUMNS & TEXT FILES
These operations separate, join etc. columns and textfiles.
Where 2 or more Infiles are required, use the File Selector and the Infile 2,3... box.Separate Columns: Split a multi-column file (e.g. Breakpoint) into separate columns and store these as distinct files.
Note that this operation can also be performed (for 2-column files) within Graph-Edit.
Outfiles: the outfile name is treated as a generic name and files with extensions .0, .1,, etc. are created from it. Soundshaper's file extension (e.g. .brk) is ignored. For example, if the Outfile name is MIDI, the files created are MIDI.0, MIDI.1, etc. Soundshaper's auto-naming can be used, though it is usually better to re-name the outfile in this case. (If you are splitting e.g. MIDI_22.txt, do not propose "MIDI_22" as the generic name or Soundshaper will say it already exists!)
Merge Columns: Merge a number of files (normally 1-column each) into one multi-column file (e.g. breakpoint). Note that this operation can also be performed (for 2-column files) within Graph-Edit.
Concatenate Files: A number of files (normally 1-column each) are joined end-to-end to create one single-column file.
Partition Column: The opposite of Concatenate: a single-column file is split into separate blocks of data and these are saved to separate files. The number of files determines how the single-column file is divided. Outfiles are named as in Separate Columns.
Partition in Rotation: A single-column file is split into separate blocks of data, in rotation, and these are saved to separate files. An example will best explain what this means: if the list 1,2,3,4,5,...28,29,30 is saved to 5 files, the first of these has the values 1,6,11,16,21,26; the second has the values 2,7,12,17,22,27; and so on. Outfiles are named as in Separate Columns.
Interleave (Columnate): Input is a multi-column file values are read line by line (across the columns) to create a single-column file. For example:1 2 3 4 5 6is read across each line to create 1,2,3,4,5,6.
It's unlikely that you would want to interleave times and values from a breakpoint file, but this finction could be used as the opposite of Partition in Rotation: merge the separate files created by partititioning, then Interleave them to reconstruct the original single-column list. Format into columns: A single-column is split into N columns: the opposite of Interleave. as the numbers are written across the line N numbers per line. For example 1,2,3,4,5,6 split into 2 columns becomes:1 2 3 4 5 62nd col. from 1st: This is a rather obscure function, which aims to create a second column that is optionally a variant of the first. The file 62,67,73,78 with added value 1 creates:
62 68 67 74 73 78Column 2 starts with Column 1's 2nd value (+N) and ends with Column 1's last value. Why anyone would want to do this is not so clear!
RETURN to top of page |