Folgendes:
Ich hab einen Polyphonen Stepsequencer gebaut... er ist 4x polyphon und soll eben auch Chords spielen können (harmonische chords wohlgemerkt...)
Die Eingabe der Noten erfolgt im "analog-style" soll heißen mittels Schiebepotentiometer. Eine klare abgrenzung zwischen den Noten ist somit optisch nicht möglich - den chord "harmonisch" zu treffen folglich ein Glückspiel, wenn ich aber damit live jame, will ich nicht mit dem kopfhörer am ohr so lange herum schieben bis es harmonisch ist --- live will ich keinen kopfhörer verwenden müssen...
Das ganze ist mit Max Msp programmiert, und schreibt die Noten direkt in den ausgewählten Ableton Midiclip, und zwar nicht mittels Noten wie C1 sondern mit zahlen wie 36, mathematische funktionen also erleichternd.
Somit brauche ich jetzt ne Funktion oder ein Table, oder Erfahrungswerte, die bestimmen welche Töne miteinander auf keinen Fall harmonieren, mit dieser Information würd ich dann was schreiben das dann auf oder abrundet zur nächst besten zahl damits "rund" klingt.
Die einzelnen Noten hab ich als integer vorliegen soll heißen C1=36 C#1=37 - also ist es mal ziemlich leicht einfach aus allen Zahlen - gerade zahlen zu machen
ich dividierte dabei die zahlen durch 2 und subrahiere den Rest von der Notenzahl
>>> 32/2=16 & Rest 0 > 32-0=32
>>> 33/2=16& Rest 1 > 33-1=32
aber das hat jetzt leider keinen Bezug zur Harmonienleere- von der ich 0 ahnung habe! Da die Vorige Rechnung 0 verbesserung im Sinne von Harmonie - mitbringt.
Ok was ich habe:
1 Oktave = 12 Noten - also 12 Nummern mit den ich mathematisch arbeiten kann, aufgeschlüsselt so:
C1=36
C#1=37
D1=38
D#1=39
E1=40
F1=41
F#1=42
G1=43
G#1=44
A1=45
A#1=46
B1=47
Hätt ich ahnung von Harmonie (nie gelernt - in der schule hat man mir jeden schwachsinn reingedrückt den ich eh nicht brauche- aber das nicht...) wäre es mir wahrscheinlich ein leichtes dazu ein programm zu schreiben... progrommiersprachen wären dann Javascribt (mag ich nicht) C (mag ich) simple mathematik (mag ich mehr) oder Max object basierendes kastl verbinden (sehr lustig)
Aber egal, gibts ne Formel für diese 12 Zahlen (bzw für mehr zahlen über die ganze tonleiter) gibts ne Funktion für sowas.
Ein Beispiel: 2 noten werden gleichzeitig angeschlagen
C1 & F#1 (36 & 42)
Unverändert lass ich dabei zum beispiel immer die niedrigste Zahl in dem Fall 36 --- die 42 Soll jetzt auf oder Abgerundet werden um harmonisch zu klingen. Komplexer wirds dann auch noch wenn 4 Noten auf einmal kommen.
Waahhhh HILFE!
ja kenn ich ist aber keine hilfe. --- sein programm arbeitet mit vorgefertigten chord presets... und aus dem java scribt was er da hat zur "berechnung" werd ich leider nicht schlau - wies halt immer so ist wenn man in ein fremdes programm schaut! hier ist sein javascribt - ich seh da die formel jetzt nicht wirklich...:
// schwarzonator 0.1 __ 16.11.2009
//
// idea and programming by Henrik Schwarz.
// Don't copy and sell please. Let me know if you find this useful and send me a message to
// [email protected] or visit www.schwarzonator.com and leave a comment.
// Thank you and have fun!
// inlets and outlets
inlets = 2;
outlets = 10;
////////////////////////////////////////////////////////////////////////////////////
// global variables
var CurrentOctave = 0;
var outNote = 0;
var NoteiD = 0; // Notenummer auf der Scala C = 1;
var SourceNote = 0;
var iVelocity = 0;
var chordValue = 3;
var CurrentNote = 0;
var spreadvalue = 0;
var octavevalue = 0;
var randomvalue = 0;
var dynamicvalue = 0;
var InputFilter = 1;
var PresetID = 1;
var SaveRootNote = 13;
AllScales = new Array();
MuteNotes = new Array();
ChordMemory = new Array(127);
SpreadTable = new Array("0o0o0", "0o0o-12","12o0o0", "0o-12o0", "0o12o0", "-12o0o12", "-12o0o0", "0o0o12", "-12o-12o12", "-12o12o12", "-24o0o24", "-24o0o12", "-12o0o24", "-24o-12o24", "-24o12o24", "-36o0o36", "-36o0o24", "-24o0o36", "-12o-36o36", "-12o-24o36", "-12o-12o36", "-12o0o36", "-12o12o36", "-12o24o36", "-12o36o36", "-36o-36o36", "-24o-36o36", "-24o-24o36", "-24o-12o36", "-24o0o36", "-24o12o36", "-24o24o36", "-24o36o36", "-24o-36o36", "0o-36o36", "0o-24o36", "0o-12o36", "0o0o36", "0o12o36", "0o24o36", "0o36o36", "0o-36o36", "12o-36o36", "12o-24o36", "12o-12o36", "12o0o36", "12o12o36", "12o24o36", "12o36o36", "12o-36o36", "24o-36o36", "24o-24o36", "24o-12o36", "24o0o36", "24o12o36", "24o24o36", "24o36o36", "24o-36o36", "-36o-12o36", "-36o-36o36", "-36o-36o36", "-36o-24o36", "-36o-12o36", "-36o0o36", "-36o12o36", "-36o24o36", "-36o36o36", "0o-36o0", "0o-24o0", "0o24o0", "0o36o0");
var spread1 = 0;
var spread2 = 0;
var spread3 = 0;
var spread4 = 0;
var Note1 = 0;
var Note2 = 0;
var Note3 = 0;
var Note4 = 0;
////////////////////////////////////////////////////////////////////////////////////
AllScales[0] = "reset_1_2_3_4_5_6_7_8_9_10_11_12";
AllScales[1] ="Leave My Head Alone Brain_1-4-8-13_1-4-11-13_3-8-11-15_4-8-11-16_1-8-11-13_4-11-13-16_3-8-13-15_8-11-15-20_8-13-16-20_8-11-16-20_11-16-20-23_11-15-20-23";
AllScales[2] = "Leave My Black Keys Alone_1-5-10-13_3-6-10-15_3-6-13-15_5-10-13-17_6-10-13-18_3-10-13-15_6-13-15-18_5-10-15-17_10-13-17-22_10-15-18-22_10-13-18-22_13-18-22-25";
AllScales[3] = "All Black_2-7-9_11-2-7_4-9-7_11-4-7_14-4-7_11-14-7_16-11-7_9-14-16_9-14-16_19-11-14_16-19-11_21-16-11";
AllScales[4] = "Hermitonic Pentatonic_1-4-8_2-9-4_13-9-4_13-9-4_1-8-4_9-13-16_13-4-9_16-8-14_9-13-16_16-8-14_9-13-16_9-13-16";
AllScales[5] = "Full Half_1-4-10-13_1-4-9-13_3-7-10-15_4-7-10-16_4-6-10-16_ 6-9-13-18_7-10-13-19_7-9-12-19_9-13-16-21_10-13-16-22_9-12-16-21_12-16-19-24";
AllScales[6] = "Half Full_1-4-8-13_2-5-9-14_2-5-8-14_4-7-11-16_5-10-13-17_5-11-13-17_7-11-14-19_8-11-17-20_8-13-16-20_8-13-17-20_11-14-17-23_11-13-16-23";
AllScales[7] = "You Are Sunshine_1-5-9-13_1-6-9-13_3-6-11-15_3-7-11-15_5-9-13-17_6-9-13-18_7-11-15-19_6-11-15-18_9-13-17-21_9-13-18-21_11-15-18-23_11-15-19-23";
AllScales[8] = "Sakamoto_1-5-8-12_3-5-8-12_9-3-5-12_10-13-8-5_15-12-8-5_6-17-10-13_8-17-10-13_11-18-15-8_9-12-17-15_10-13-18-15_22-11-18-15_20-12-17-15";
AllScales[9] ="Strings Of D_2-9-13-4_2-6-13-9_4-7-11-13_4-7-12-14_4-7-11-14_6-9-13-16_7-11-18-13_7-11-14-18_9-13-16-2_7-11-16-19_11-16-19-23_12-16-19-23";
AllScales[10] = "Anime_1-15-8-13_1-17-8-13_3-22-17-15_3-10-6-15_5-13-8-17_11-18-15-23_6-15-11-18_8-18-13-20_11-18-13-23_10-24-17-22_10-26-17-22_11-18-15-23";
AllScales[11] = "Michael_2-7-10-14_2-5-9-14_4-9-12-16_4-7-12-16_5-7-12-17_7-12-16-19_7-10-14-19_9-14-19-21_9-12-16-21_10-14-17-22_12-14-19-24_12-16-19-24";
AllScales[12] = "Âme Rej_1-9-6-13_3-10-6-15_3-10-6-11_3-10-8-11_5-12-8-17_6-11-8-17_6-14-10-17_8-14-11-17_8-14-11-20_8-15-11-18_6-15-10-18_5-15-11-20";
AllScales[13] ="Bugge Wesseltoft 1_1-3-6-10_1-3-6-10_3-5-8-11_3-5-8-11_6-8-11-15_6-8-11-15_6-8-11-15_8-10-13-17_8-10-13-17_8-10-13-17_11-13-17-20_11-13-17-20";
AllScales[14] = "FranG_1-4-7-11_3-6-11-13_4-6-9-13_6-9-11-13_6-11-14-16_6-9-11-15_8-11-13-16_9-13-16-18_11-13-15-18_11-13-16-18_11-16-18-21";
var CurrentScale = AllScales[1];
////////////////////////////////////////////////////////////////////////////////////
ChordScales = CurrentScale.split("_");
post();
post("schwarzonator scripted loaded!!!");
////////////////////////////////////////////////////////////////////////////////////
function Matrix (SourceNote, noteVelocity, BaseNote)
{
if (noteVelocity != 0){
if (InputFilter != 0){
// reset all
for (i=0; i<128;i++){
ChordMemory[i] = "";
outlet(4, 0 );
outlet(3, i);
}
outlet(8, "1"); // flush
}
MyChord = ChordScales[SourceNote].split("-");
RandomOctave = CurrentOctave + (Math.round( Math.random()*randomvalue*2 - randomvalue));
Note1 = RandomOctave * 12 + Number(MyChord[0]) - 1 + spread1; // Erste Note
RandomOctave = CurrentOctave + (Math.round( Math.random()*randomvalue*2 - randomvalue));
Note2 = RandomOctave * 12 + Number(MyChord[1]) - 1 + spread2; // Zweite Note
RandomOctave = CurrentOctave + (Math.round( Math.random()*randomvalue*2 - randomvalue));
Note3 = RandomOctave * 12 + Number(MyChord[2]) - 1 + spread3; // Dritte Note
RandomOctave = CurrentOctave + (Math.round( Math.random()*randomvalue*2 - randomvalue));
Note4 = RandomOctave * 12 + Number(MyChord[3]) - 1 + spread4; // Dritte Note
ChordMemory[BaseNote] = Note1 + "o" + Note2 + "o" + Note3 + "o" + Note4;
//////////////// Output der Noten
outlet(4, noteVelocity + (Math.round(Math.random()*dynamicvalue*2-dynamicvalue)) );
outlet(3, Note1);
if (chordValue > 1 && Note2 > 0){
outlet(4, noteVelocity + (Math.round(Math.random()*dynamicvalue*2-dynamicvalue)) );
outlet(3, Note2 );
}
if (chordValue > 2 && Note3 > 0){
outlet(4, noteVelocity + (Math.round(Math.random()*dynamicvalue*2-dynamicvalue)) );
outlet(3, Note3);
}
if (chordValue > 3 && Note4 > 0){
outlet(4, noteVelocity + (Math.round(Math.random()*dynamicvalue*2-dynamicvalue)) );
outlet(3, Note4);
}
} else {
MuteNotes = ChordMemory[BaseNote].split("o");
if (Number(MuteNotes[0] > 0)){
outlet(4, 0 );
outlet(3, Number(MuteNotes[0]));
}
if (Number(MuteNotes[1] > 0)){
outlet(4, 0 );
outlet(3, Number(MuteNotes[1]));
}
if (Number(MuteNotes[2] > 0)){
outlet(4, 0 );
outlet(3, Number(MuteNotes[2]));
}
if (Number(MuteNotes[3] > 0)){
outlet(4, 0 );
outlet(3, Number(MuteNotes[3]));
}
}
////////////////
}
////////////////////////////////////////////////////////////////////////////////////
function chorder (chord)
{
chordValue = chord;
}
////////////////////////////////////////////////////////////////////////////////////
function spreader (spreadin)
{
spreads = SpreadTable[spreadin].split("o");
spread1 = Number(spreads[0]);
spread2 = Number(spreads[1]);
spread3 = Number(spreads[2]);
outlet(8, 1);
post();
post("spreader: " + SpreadTable[spreadin] + " -- " + spreads.join(" / ") );
}
////////////////////////////////////////////////////////////////////////////////////
function wurfler (randomin)
{
randomvalue= Math.round(randomin/20);
}
////////////////////////////////////////////////////////////////////////////////////
function octaver (octavein)
{
octavevalue= octavein;
}
////////////////////////////////////////////////////////////////////////////////////
function dynamicer (dynin)
{
dynamicvalue= dynin;
}
////////////////////////////////////////////////////////////////////////////////////
function inputF(SetOn){
post();
post("Filter: " + SetOn);
if (SetOn == 1){
InputFilter = 1;
} else {
InputFilter = 0;
}
}
////////////////////////////////////////////////////////////////////////////////////
function presetter (PresetID)
{
outlet(8, 1); // flush
CurrentScale = AllScales[PresetID];
ChordScales = CurrentScale.split("_");
// send current scale to network
outlet(7, CurrentScale);
// reset all
for (i=0; i<128;i++){
outlet(6, 0 );
outlet(5, i);
outlet(4, 0 );
outlet(3, i);
}
// display correct notes
for (i=1; i<13;i++){
DisplayNote = ChordScales[i].split("-");
for (n=0; n<8;n++)
{
outlet(6, 100 );
outlet(5, (Number(DisplayNote[0])+23)+ n*12);
}
}
}
////////////////////////////////////////////////////////////////////////////////////
function helloBrother (){
// send current scale to network
outlet(7, CurrentScale);
}
////////////////////////////////////////////////////////////////////////////////////
function msg_int (iNote, velola)
{
CurrentNote = iNote;
iNote = iNote + (octavevalue*12)
outlet(0, CurrentNote);
CurrentOctave = Math.floor(iNote / 12);
outlet(2, CurrentOctave );
sNoteiD = iNote - (CurrentOctave*12)+1;
// Send root note to network if note changes only
if (velola != 0 && NoteiD != SaveRootNote){
SaveRootNote = sNoteiD;
outlet(1 , sNoteiD);
}
Matrix (sNoteiD, velola, CurrentNote);
}
////////////////////////////////////////////////////////////////////////////////////
function ReadChordSetNames (){
ArraySize = AllScales.length;
for (n=0;n<ArraySize;n++){
ReadFromScale = AllScales[n].split("_");
Name = ReadFromScale[0];
outlet(9, Name);
}
}
////////////////////////////////////////////////////////////////////////////////////
weil es geht mir nicht darum das aus einzelenen noten Chords gemacht werden ---
weil ich habe wie gesagt schon chords - eben 4 sequencer spuren übereinander - (und dafür ein hardware interface)
diese sollen nun untereindaer gut zusammen passen---soll heißen ich brauch keine chord presets - ich brauch den mathematischen zusammenhang. damit ich wenn ich 4 spuren habe - eine spur als Fix betrachte und alle anderen müsse sich um eine oder mehrer noten verschieben (immer den kleinsten sprung) damit sie passen --- es soll somit ein programm sein das mathematisch auf das reagiert was ich mit midicontrolleren eingebe - und dabei keine preset sets brauche - weil die müsst ich ja erst wieder programmieren - und das wäre dann wieder nicht Live ... es geht eben ums jamen...
nebenbei - den schwarzenator nutz ich auch - aber halt nicht auf der hauptsequencer spur.
http://de.wikipedia.org/wiki/Funktionstheorie glaub da is die spur die du suchst...
b.z.w edith meint:
http://de.wikipedia.org/wiki/Pentatonik
hier mal ein kurzes video das zeigen soll wos problem liegt...bzw den patch in aktion zeigt (beta) http://www.phatline.at/m4l/FSQ1-3-beta.wmv
wort mal auweh fehler im system... ganztöne sind nicht gleich gerade zahlen, und lautn dele sein link müssten dann ganze noten eh immer auf einander passen ich muss also sicherstellen das die jeweilige halbtonnote immer auf ne ganze geschoben wird und passta (vermutlich)
A0=21
A#0=22
B0=23
C1=24
C#1=25
D1=26
D#1=27
E1=28
F1=29
F#1=30
G1=31
G#1=32
A1=33
A#1=34
B1=35
C2=36
C#2=37
D2=38
D#2=39
E2=40
F2=41
F#2=42
G2=43
G#2=44
A2=45
A#2=46
B2=47
C3=48
C#3=49
D3=50
D#3=51
E3=52
F3=53
F#3=54
G3=55
G#3=56
A3=57
A#3=58
B3=59
C4=60
C#4=61
D4=62
D#4=63
E4=64
F4=65
F#4=66
G4=67
G#4=68
A4=69
A#4=70
B4=71
C5=72
C#5=73
D5=74
D#5=75
E5=76
F5=77
F#5=78
G5=79
G#5=80
A5=81
A#5=82
B5=83
C6=84
C#6=85
D6=86
D#6=87
E6=88
F6=89
F#6=90
G6=91
G#6=92
A6=93
A#6=94
B6=95
C7=96
C#7=97
D7=98
D#7=99
E7=100
F7=101
F#7=102
G7=103
G#7=104
A7=105
A#7=106
B7=107
C8=108
Also du hast viele Probleme die Musik rein musikalisch zu betrachten. Ersteinmal der Grundbegriff den du brauchst ist das Intervall - also zwei Töne die ein einem bestimmten Abstand zueinander stehen. Davon ist eigentlich nur die Oktave wirklich fix: der höhere Ton hat die doppelte Frequenz vom tieferen.
Aber da kommt schon mal das erste Problem: in wie viele Töne unterteilt man die Oktave. Wenn man es einfach europäisch halten will nimmt man da einfach 12 Töne. Wie man das unterteilt ist aber schon wieder das nächste Problem. Wir haben also die Töne T0, T1, T2, T3, .... T12 = 2*T0. Willst du es dir mathematisch einfach machen wird das Verhältnis immer gleich sein, also T1 / T0 = T2 / T1 = T3 / T2 = ... = k und daraus folgt T0 * k = T1 * k = T2 *k = ... = T11 * k = T12 -> T0 * k^12 = T12 = 2*T0 -> k = zwölfte Wurzel aus 2.
Also wir haben jetzt die Töne die für uns einfach klingen und alle schön einfach definiert. Neben der Oktave, also dem Intervall von T0 zu T12, gibt es noch die Intervalle zu allen anderen Tönen von T0 aus. Die werden nicht alle so schön klingen wie möglich, weil wir die Tonabstände so einfach definiert haben, aber dafür rechnet es sich einfach.
Gut, nächte Sache: die Tonleiter und damit kommen wir zu den Kirchentonarten um es wieder einfach zu halten. Grundlage da ist, dass wir vom Grundton normalerweise zum übernächsten springen, ausser bei zwei Ausnahmen. Bekannt sind da die Dur-Tonleiter (ionisch) und die Moll-Tonleiter (äolisch). Am Klavier erkennt man die an den weißen Tasten - von C aus ist es Dur, von A aus Moll. Geht man von einem anderen Ton aus braucht man Vorzeichen und zumindest die Anzahl merkt man sich leicht mit dem Quintenzirkel (Geh du alter Esel hol Fische, Frisches Brot essen asoziale Despoten gestern).
Schön, wir kennen unsere Töne und die Tonleiter. Die Akkorde sind jetzt bestimmte Töne aus der Tonleiter. Z.B. für C-Dur der erste, der dritte und der fünfte: C - E - G. Jetzt gibt es aber noch andere, wie C7, C9, C-sus, C-dim ... Jeder hat seine Berechtigung aber, weil Akkorde eben nicht für sich alleine verwendet werden hängen sie von anderen Akkorden ab. Klassisches Blues-Schema wäre 4xI,4xIV, 4xI, 1xV, 1xIV, 2xV, wobei I z.B. mit C-Dur ergibt IV = F, V = G und je nachdem dann vielleicht mal ein Septakkord.
Im Grunde kommst du am Schluss rein mathematisch gesehen nicht zum einem Ergebnis, dass die sagt ob zwei oder mehr Töne in einer größeren Abfolge zusammen passen sondern nur eine Wahrscheinlichkeit, die je nach Schema auf das du dich einschränken willst höher oder niedriger sein kann.
hm den durchblick hab ich noch nicht...ich hab mal folgendes...wenn ich alle halbtöne lösche dann bleiben folgende midinoten übrig:
die ganze noten:
21
23
24
26
28
29
31
33
35
36
38
40
41
43
45
47
48
50
52
53
55
57
59
60
62
64
65
67
69
71
72
74
76
77
79
81
83
84
86
88
89
91
93
95
96
98
100
101
103
105
107
108
und die halbtöne:
22
25
27
30
32
34
37
39
42
44
46
49
51
54
56
58
61
63
66
68
70
73
75
78
80
82
85
87
90
92
94
97
99
102
104
106
Frage nur wie ich das ganze mit ner einfachen Formel hinbiegen kann...mir fällt schon was kompliziertes dazu ein wie man das lösen könnte... aber das ganze muss ja ein system haben das man nutzen kann!
Die Vorgabe könnte heißen: wenn du ne halbe note bist dann wähle immer die nächste ganze note - im zweifelsfall aber die niedrigere
Wenn ich die halb note 85 habe soll sie sich auf 84 ändern.
Wenn ich die halb note 87 habe soll sie sich auf 86 ändern.
Wenn ich die halb note 90 habe soll sie sich auf 89 ändern.
Wenn ich die halb note 92 habe soll sie sich auf 91 ändern.
Wenn ich die halb note 94 habe soll sie sich auf 93 ändern.
Das würde aber heißen halb note-1 = immer ganze note. soweit zur Berechnung wenn sie mal identifiziert ist als halbnote. wie also Identifiezieren? Ich könnte jetzt jede Note mit der ganzen Halbtontabelle vergleichen lassen, und wenn sie identifziert ist sie mit 1 sutbrahieren --- Das wiederum würde ne Menge zeit beanspruche - wäre leiwand wenn das Logischer und einfacher ginge - sprich mathematische funktion! wer nen Tip?
danke für die erklärung, auch wenn ich nicht ganz durchsteige was du mit T0 k und soweiter meinst (weil wie gesagt - in der schule wo ich war, gabs quasi keinen musikunterricht, und in mathe kams auch nicht vor)
aja was ich jetzt beim expirmentieren draufkomme, das nutzen von halbton ONLY - führt praktisch immer zu harmonischen zuständen ---im gegensatz von ganztönen >> weil mit diese sprung bei F und E kommts disharmonisch rüber.
Also auf die halbtöne konzentrieren - mit denen müßt das worken. was heißt das aber für unsere Rechnung?
Die Vorgabe könnte heißen: wenn du ne ganze note bist dann wähle immer die nächste halbnote - im zweifelsfall aber die niedrigere
Wenn ich die ganze note 60 habe soll sie sich auf 61 ändern. +1
Wenn ich die ganze note 62 habe soll sie sich auf 61 ändern. -1
Wenn ich die ganze note 64 habe soll sie sich auf 63 ändern. -1
Wenn ich die ganze note 65 habe soll sie sich auf 66 ändern. +1
Wenn ich die ganze note 67 habe soll sie sich auf 66 ändern. -1
Wenn ich die ganze note 69 habe soll sie sich auf 68 ändern. -1
Wenn ich die ganze note 71 habe soll sie sich auf 70 ändern. -1
übesichtlicher:
60 61 +1
62 61 -1
64 63 -1
65 66 +1
67 66 -1
69 68 -1
71 70 -1
mit Ganzen noten is leichter da ham ma nur -1 gebraucht, jetzt ham ma beides drinnen....
Da ich erst mit Max MSP jetzt wieder mit Mathe in berührung komme und ich das seit pff ein jahrzent nimmer gebraucht habe - ist das für mich schon ziemlich hardcore da ne einfach Rechnung raus zu kristallisieren.
ja habs jetzt mit der halbtonlösung gemacht ... das vereinfacht die mucke die rauskommet extrem --- aber techno muss ja nicht kompliziert sein
jetzt ganz ohne mathematik, einfach die "select" lösung... naja wie bild:
laut dieser Table halt:
ganze <resultierende> halbe
21 22
23 22
24 25
26 25
28 27
29 30
31 30
33 32
35 34
36 37
38 37
40 39
41 42
43 42
45 44
47 46
48 49
50 49
52 51
53 54
55 54
57 56
59 58
60 61
62 61
64 63
65 66
67 66
69 68
71 70
72 73
74 73
76 75
77 78
79 78
81 80
83 82
84 85
86 85
88 87
89 90
91 90
93 92
95 94
96 97
98 97
100 99
101 102
103 102
105 104
107 106
108 106
jetzt werd ich noch diverse modi einbauen...ganzton modi, halbton modi, & und einen der die unterste note aufgreift bestimmt auf halb ton und ganzton und ihren chord danach anpasst...also ganzton und halbton in einem modi....
wie auch immer die ergebnisse vom halbtonmod gefallen schon ganz gut
Jetzt ist mir auch bewusst warum zwei meiner musikalischen Pioniere einen Abschluss in Mathematik haben.
wä leiwander wenn du einer davon wärst... dann könntst ma helfen (weil ich will ein tool, das jeder depp bedienen kann, ohne den blassesten schimmer von mathe oder musik zu haben ---mein hochgestecktes ziel --vereinfachen---vereinfachen---vereinfachen... so vereinfache das wirklich jeder gscheiden techno machen kann... damit wenn ich mal demenz oder sonst nimmer ganz dicht bin trozdem mucke machen kann...na stimmt nicht deswegen nicht...eigentlich gehts ma drum - das es wie Radfahren wird...schnelle lernkurve und dann hot mans)
? kannst ein bischen deutlicher mit mir reden? bist du der entwickler von buzz und ich soll mit dir reden? oder was meinst jetzt?
schade
http://www.phatline.at/m4l/Video16.wmv
ja danke für die mühe das zu erklären
dann mach ichs gleich mit noten (auch wenn ich mich noten nicht auskenne, und ich mit frequenz als techniker vermutlich mehr angefangen habe...)
ich muss also analysieren, ob den nun ein bekannter chord in der unmittelbaren nähe liegt (sprich von 3 angeschlagenen noten liegen 2 schon mal korrekt, und die vierte muss nur noch um einen halbton verschoben werden um den bekannten chord zu bilden)
Wenn das nicht der Fall ist (das mindestens 2 noten in ein chordschema passen) wird eine Basisnote angenommen (bzw vorher eingestellt) - von mir aus die tiefste, und die 3 Noten so hingeschoben das sie harmonisch sind (z.b. wie jetzt schon gehabt halbtöne -das funkt ja...... bei den ganzen Noten oder Tönen wie auch immer man das nennt - ist die rechnung schon schwieriger - aber lösbar)
muss ich also nur noch kappieren was du geschrieben hast, und ob ich das als mathe leihe bzw als programmierer anfänger hinbiegen kann...
hab dies Problemetik noch nicht gelöst, ehrlich gesagt fehlt mir auch die mathematische Motivation im Moment, hab lieber an meinen freihen Tag mein erstes Multitouch Interface für diesen Patch programmiert... ist für den 2 Finger Multitouch Monitor ACER T230 Konzipiert (23" full HD). und funktioniert.
Unterstützt von Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)