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.

Waren das nicht die Obertöne die bestimmen, welche Chords mit einer Note möglich sind oder so? Frequenzanalysiertes umstimmen der folgenote oder so willst du... da könnt dir doch melodyne helfen...

edith sagt: wobei i da jetzt net weiss ob des mit midi was anfangen kann... beim resultat könnts aber hilfreich sein...

Wenn du mit der Folgenote die nächste Note in der Notenskala - aber zum gleichen Zeitpunkt meinst - ja - umstimmen der zweiten Note wenn man 2 Noten gleichzeitig angeschlagen hat - die erste note soll in ihrer Tonhöhe unverändert bleiben --- wenn ich jetzt wieder 2 neue Noten anschlage - dann ist das wieder eine neue operation und hat mit der vorigen nix mehr zu tun ---also aufeinanderfolgende noten sollten nicht beachtet werden - dafür gibts ja den sequencer ---- der sequencer seine schwachstelle ist halt sein stufenloses nichtgerastertes Interface ---eben analoge Potis... deshalb auch das programm - das das ganze in der Tonhöe quantisiert.

Obertöne sind doch ganze octave sprünge oder? Und frequenzanalyse und midi ich weis nicht --- wie gesagt ich hab ne oktave und die hat 12 zahlen - das ist das was Midi bzw Max in einem standartisierten Synthesizer setup zu lässt...

Funktionstheorie (wiki) glaub da is die spur die du suchst...


b.z.w edith meint:
Pentatonik@wiki

hier mal ein kurzes video das zeigen soll wos problem liegt...bzw den patch in aktion zeigt (beta) dowload wmv file 73mb

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)

Um die größere Abfolge gehts mir gar nicht - soweit will ich gar nicht gehen, mir gehts nur um den einzelen klang das dieser nicht -vereinfacht ausgedrückt- "kacke" klingt.
Klassische Notenabfolgen (bzw chordabfolgen) (in der Zeitebene jetzt) muss ich nicht haben - das macht dann der zufall, bzw meine hand, ich schieb einfach die regler solang das sie passen...aber ein bischen unterstützung das zumindest der einzelne step für sich gut klingt ist das was ich jetzt suche.

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

Nur die Frage dazu ist ob man dies berechnet? Z.b. mit Frequenzen. -oder:
Ob man dies mit Tabellen macht -und diese mit den eingehenden zahlen vergleicht - da bleibt die Frage - gibts da Tabellen dafür und kann ich die gscheid lesen (also nix notenblatt mit note und haxen drauf) sondern:
C1 + D#1 + F#1 + D2 ...bzw gleich mit Midizahlen wie 32 + 44 + 55 + 66

Aber ich schätz mal das geht mit Frequenzen, keine ahnung wie das unser Hirn macht- aber ich schätz mal auch mit Frequenzen (ob etwas gut klingt oder nicht) also harmonisch oder nicht... du hast da eh schon was geschrieben mit T0/T1 == T2/....hatte aber da keinen Schimmer was du mit T 0 und soweiter meinst ---und ob das genau das ist - was ich jetzt suche (ich will einfach nicht zu lange in die falsche Richtung laufen... ich will das prorgramm schreiben, und die Musiklehre mal wieder ganz schnell vergessen!...)

Auf ner Seite hab ich folgende Formel gefunden:
n=0:1/12:10;
f=2.^n'*13.75;
printf('%.6f\n',f)
sie soll aus Notenzahlen (z.b. 33) ne Frequenz machen... 13,75 ist das der Octaven schritt also von C1 zu B1? Auf 13,75 muss man ja auch erst mal mathematisch kommen ---au back.


ajo video zum halbtonmod lad ich grad hoch.

ja hört sich ziemlich nach easy listening, oder so african trommelmusik an... - ich belass dem patch mal diesen modus... aber werd versuchen da doch noch ihrgendwie akkorde zu erkenn.

Nur die Frage dazu ist ob man dies berechnet? Z.b. mit Frequenzen. -oder:
Ob man dies mit Tabellen macht -und diese mit den eingehenden zahlen vergleicht - da bleibt die Frage - gibts da Tabellen dafür und kann ich die gscheid lesen (also nix notenblatt mit note und haxen drauf) sondern:
C1 + D#1 + F#1 + D2 ...bzw gleich mit Midizahlen wie 32 + 44 + 55 + 66

Aber ich schätz mal das geht mit Frequenzen, keine ahnung wie das unser Hirn macht- aber ich schätz mal auch mit Frequenzen (ob etwas gut klingt oder nicht) also harmonisch oder nicht... du hast da eh schon was geschrieben mit T0/T1 == T2/....hatte aber da keinen Schimmer was du mit T 0 und soweiter meinst ---und ob das genau das ist - was ich jetzt suche (ich will einfach nicht zu lange in die falsche Richtung laufen... ich will das prorgramm schreiben, und die Musiklehre mal wieder ganz schnell vergessen!...)

Auf ner Seite hab ich folgende Formel gefunden:
n=0:1/12:10;
f=2.^n'*13.75;
printf('%.6f\n',f)
sie soll aus Notenzahlen (z.b. 33) ne Frequenz machen... 13,75 ist das der Octaven schritt also von C1 zu B1? Auf 13,75 muss man ja auch erst mal mathematisch kommen ---au back.





440Hz - 880Hz = 12 Schritte = 1 Oct
880/2= 440
440/12= 36,66
220/12= 18,33
36,66/2= 18,33
usw


ajo video zum halbtonmod lad ich grad hoch.

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)

http://www.buzzmachines.com/ ?

? kannst ein bischen deutlicher mit mir reden? bist du der entwickler von buzz und ich soll mit dir reden? oder was meinst jetzt?

Ich wollte dich damit auf Buzz aufmerksam machen. Die Community dahinter ist riesig und bietet abartig viel Plugins und Tools an die automatisieren. Und das ganze auf Freeware Basis. Entwickler bin ich keiner. Lediglich Gelegenheitsuser.

schade

link 200mb wmv file 9 minuten...halbtonmodus

T0 ist erste Ton von den Zwölf und beim dreizehnten kommst du wieder zur Oktav. Wenn du z.B. bei A anfangst mit 440 Hz und wie gesagt das Verhältnis zwischen zwei Tönen die zwölfte Wurzel aus 2 bzw. 2^(1/12) = 1,0595 ist, gehts in Halbtonschritten weiter: T0 = 440Hz, T1 = 440Hz*1,0595 = 466,2 Hz, T2 = T1*1,0595 = T0*1,0595*1,0595 = T0*1,0595^2 = 493,9 Hz, T3 = T0*1,0595^3, ... und nach zwölf Schritten dann: T12 = T0*1,0595^12 = 880Hz = T0 * 2^(1/12)^12 = T0 * 2 QED.



Wenn du gleich in einer bestimmten Tonleiter arbeitest reichen die Noten aus. In Dur oder Moll hast du zwei Halbtonschritte und sonst Ganztonschritte - in C-Dur sind z.B. die Halbtonschritte zwischen E und F, und zwischen H und C, also dort wo die schwarzen Tasten fehlen. Alle anderen sind transponiert und bestehen auch aus den normalen Tönen C, D, E, F ... H, außer dort wo sie ihre Vorzeichen haben, siehe Quintenzirkel, also z.B. in G-Dur eins und das ist von F nach Fis: G, A, H, C, ... E, Fis, G.

Und wenn wir nun die Töne aus der Tonleiter mit römischen Zahlen schreiben haben wir die normale Notation für Akkorde: I - III - V ist ein Dur Akkord, also in C-Dur der erste, dritte und fünfte Ton der Tonleiter also C - E - G. Für den Septakkord kommt noch der verminderte siebte dazu: also in C-Dur H einen Halbton niedriger ergibt: C - E - G - B. Bei Moll ist einfach der dritte Ton einen Halbton niederiger: C - Es - G

Um wieder zur Mathematik zu kommen. Vom ersten zum Dritten Ton sind es in Dur zwei Ganztonschritte = 4 Halbtonschritte, und weiter zum fünften ein Halb- und ein Ganztonschritt = 1 + 2 = 3 Halbtonschritte. Wenn also zwischen den angespielten Tönen zuerst 4 und dann 3 Halbtonschritte liegen ist es Dur und sonst nicht. Wobei vielleicht noch Dur mit dem tiefsten Ton der nicht der Grundton ist interessant ist, wie in G - E - C, oder E - C - G, zwischen E und C liegen 12 - 4 - 3 Halbtöne = 5 Halbtöne, die Abstände 4 und 3, 3 und 5, 5 und 4 sind jeweils passend für Dur. Bei Moll ist einfach der erste Abstand nur 3 Halbtöne, dafür der zweite 4.

Das lässt sich dann wieder beliebig erweitern für mehr Abstände wie z.B. eben wieder bei den Septakkorden (4, 3, 3; und 2 zur Oktave) usw. Die Frage ist dann nur was du machst wenn die Töne nicht in das Schema passen, z.B. C - E - Gis ist einen Halbton von C-Dur C-E-G entfernt, oder einen von A-Moll A-C-E, oder einen von E-Dur: E-Gis-H, oder einen von Gis-Dur: Gis - C - Dis .....

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.