You could save the note numbers in an array? That wouldn't bloat the
code too much.

On 19 May 2014 17:06, Stefan Thomas  wrote:
> Dear community,
> I want to allocate two different sounds to different midi-keys.
> My aim is to get one sound for the black and another sound for the white
> keys.
> I've started with the following code which works.
> But my question is:
> Is the maybe a more confortabe way to do this? If I use my method the if
> condition would be very long!
> Here is my code:
> 
> 
> -odac -Ma -m0d
> 
> ; ==============================================
> 
>
> sr    =    44100
> nchnls    =    2
> 0dbfs    =    1
> gisine ftgen 0,0,2^13, 10, 1
> alwayson 1
> massign 0, 1
> instr 1
>     iamp     ampmidi 0.2
>     icps     cpsmidi
>     inotnum    notnum
>     iatt     = 0.01
>     idur     = 3
>     irel     = 0.1
>     aenv     linsegr 0,iatt,1,idur,0,irel,0
>     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) || (inotnum
> == 65) ) then
>     aout    poscil    aenv*iamp,icps
>     else
>     aout    rand    aenv*iamp
>     endif
>     outs    aout, aout
> endin
>
> 
> ; ==============================================
> 
>
> 
> 
>
>
>

An array would be a good generic solution.  For one specific to just
black-key or white key, you might want to write a UDO that checks if a
note num is a black key.  Something like:

opcode is_black_key, i, i
   inotenum xin
   ival = inotenum % 12
   xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival == 10)
endop



On Mon, May 19, 2014 at 12:10 PM, Rory Walsh  wrote:
> You could save the note numbers in an array? That wouldn't bloat the
> code too much.
>
> On 19 May 2014 17:06, Stefan Thomas  wrote:
>> Dear community,
>> I want to allocate two different sounds to different midi-keys.
>> My aim is to get one sound for the black and another sound for the white
>> keys.
>> I've started with the following code which works.
>> But my question is:
>> Is the maybe a more confortabe way to do this? If I use my method the if
>> condition would be very long!
>> Here is my code:
>> 
>> 
>> -odac -Ma -m0d
>> 
>> ; ==============================================
>> 
>>
>> sr    =    44100
>> nchnls    =    2
>> 0dbfs    =    1
>> gisine ftgen 0,0,2^13, 10, 1
>> alwayson 1
>> massign 0, 1
>> instr 1
>>     iamp     ampmidi 0.2
>>     icps     cpsmidi
>>     inotnum    notnum
>>     iatt     = 0.01
>>     idur     = 3
>>     irel     = 0.1
>>     aenv     linsegr 0,iatt,1,idur,0,irel,0
>>     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) || (inotnum
>> == 65) ) then
>>     aout    poscil    aenv*iamp,icps
>>     else
>>     aout    rand    aenv*iamp
>>     endif
>>     outs    aout, aout
>> endin
>>
>> 
>> ; ==============================================
>> 
>>
>> 
>> 
>>
>>
>>
>
>
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>
>
>

On Mon, 19 May 2014, Stefan Thomas wrote:
> Is the maybe a more confortabe way to do this? If I use my method the if
> condition would be very long!

Because the pattern of black and white notes repeats every 12 notes, you
could take the note number modulo 12, and then test the result of that
against five different values (for the black notes; anything else would be
white), which should be a manageable size for the if condition.  More
concise ways of doing it are probably possible but might be harder to
understand and thus create maintainability problems.

-- 
Matthew Skala
mskala@ansuz.sooke.bc.ca                 People before principles.
http://ansuz.sooke.bc.ca/

nice code - thanks.
	joachim


Am 19.05.2014 18:22, schrieb Steven Yi:
> An array would be a good generic solution.  For one specific to just
> black-key or white key, you might want to write a UDO that checks if a
> note num is a black key.  Something like:
>
> opcode is_black_key, i, i
>     inotenum xin
>     ival = inotenum % 12
>     xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival == 10)
> endop
>
>
>
> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh  wrote:
>> You could save the note numbers in an array? That wouldn't bloat the
>> code too much.
>>
>> On 19 May 2014 17:06, Stefan Thomas  wrote:
>>> Dear community,
>>> I want to allocate two different sounds to different midi-keys.
>>> My aim is to get one sound for the black and another sound for the white
>>> keys.
>>> I've started with the following code which works.
>>> But my question is:
>>> Is the maybe a more confortabe way to do this? If I use my method the if
>>> condition would be very long!
>>> Here is my code:
>>> 
>>> 
>>> -odac -Ma -m0d
>>> 
>>> ; ==============================================
>>> 
>>>
>>> sr    =    44100
>>> nchnls    =    2
>>> 0dbfs    =    1
>>> gisine ftgen 0,0,2^13, 10, 1
>>> alwayson 1
>>> massign 0, 1
>>> instr 1
>>>      iamp     ampmidi 0.2
>>>      icps     cpsmidi
>>>      inotnum    notnum
>>>      iatt     = 0.01
>>>      idur     = 3
>>>      irel     = 0.1
>>>      aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>      if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) || (inotnum
>>> == 65) ) then
>>>      aout    poscil    aenv*iamp,icps
>>>      else
>>>      aout    rand    aenv*iamp
>>>      endif
>>>      outs    aout, aout
>>> endin
>>>
>>> 
>>> ; ==============================================
>>> 
>>>
>>> 
>>> 
>>>
>>>
>>>
>>
>>
>> Send bugs reports to
>>          https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>>
>>
>>
>
>
> Send bugs reports to
>          https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>
>
>
>

Given this either/or requirement, another way is to use a one-octave 
look-up table (a sort of sieve) identifying each note, e.g. 
0,1,0,1,0,0,1,0,1,0,1,0), then use the modulo result from the midi note 
as the index into the table. This should keep the number of comparison 
tests to a minimum.

Richard Dobson



On 19/05/2014 18:23, joachim heintz wrote:
> nice code - thanks.
>      joachim
>
>
> Am 19.05.2014 18:22, schrieb Steven Yi:
>> An array would be a good generic solution.  For one specific to just
>> black-key or white key, you might want to write a UDO that checks if a
>> note num is a black key.  Something like:
>>
>> opcode is_black_key, i, i
>>     inotenum xin
>>     ival = inotenum % 12
>>     xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival == 10)
>> endop
>>
>>
>>

Looks like more of your email was cut? You tried with what?

On 20 May 2014 08:56, Stefan Thomas  wrote:
> Sorry, the mail was sended too early:
> again:
>
> I've created an array with (some) black keys:
> iblackkeys[ ] fillarray 61,63,66,68,70
> But how can I check if inotnum is equal to one of the numbers in the array?
> I've tried it with:
>
> I've created an array with (some) black keys:
> iblackkeys[ ] fillarray 61,63,66,68,70
> But this (as I expected) does not work.
>
>
> 2014-05-20 9:53 GMT+02:00 Stefan Thomas :
>
>> Dear Rory,
>> I've tried it with Your idea of using an array.
>> I've created an array with (some) black keys:
>> iblackkeys[ ] fillarray 61,63,66,68,70
>>
>>
>>
>> 2014-05-19 18:10 GMT+02:00 Rory Walsh :
>>
>>> You could save the note numbers in an array? That wouldn't bloat the
>>> code too much.
>>>
>>> On 19 May 2014 17:06, Stefan Thomas  wrote:
>>> > Dear community,
>>> > I want to allocate two different sounds to different midi-keys.
>>> > My aim is to get one sound for the black and another sound for the
>>> > white
>>> > keys.
>>> > I've started with the following code which works.
>>> > But my question is:
>>> > Is the maybe a more confortabe way to do this? If I use my method the
>>> > if
>>> > condition would be very long!
>>> > Here is my code:
>>> > 
>>> > 
>>> > -odac -Ma -m0d
>>> > 
>>> > ; ==============================================
>>> > 
>>> >
>>> > sr    =    44100
>>> > nchnls    =    2
>>> > 0dbfs    =    1
>>> > gisine ftgen 0,0,2^13, 10, 1
>>> > alwayson 1
>>> > massign 0, 1
>>> > instr 1
>>> >     iamp     ampmidi 0.2
>>> >     icps     cpsmidi
>>> >     inotnum    notnum
>>> >     iatt     = 0.01
>>> >     idur     = 3
>>> >     irel     = 0.1
>>> >     aenv     linsegr 0,iatt,1,idur,0,irel,0
>>> >     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>> > (inotnum
>>> > == 65) ) then
>>> >     aout    poscil    aenv*iamp,icps
>>> >     else
>>> >     aout    rand    aenv*iamp
>>> >     endif
>>> >     outs    aout, aout
>>> > endin
>>> >
>>> > 
>>> > ; ==============================================
>>> > 
>>> >
>>> > 
>>> > 
>>> >
>>> >
>>> >
>>>
>>>
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>>
>

Yes, and most likely yes! I think the modulo idea is probably the best
and most efficient. If you were dealing with array you could use any
type of loop construct. There are quite a few options.

On 20 May 2014 15:30, Stefan Thomas  wrote:
> Oh yes, sorry:
> The question is: how can I check, if a midinote number is one of the numbers
> of an array.
> Do I need  a loop-construction for this?
> Won't the instrument slower with that?
>
>
>
> 2014-05-20 12:43 GMT+02:00 Rory Walsh :
>
>> Looks like more of your email was cut? You tried with what?
>>
>> On 20 May 2014 08:56, Stefan Thomas  wrote:
>> > Sorry, the mail was sended too early:
>> > again:
>> >
>> > I've created an array with (some) black keys:
>> > iblackkeys[ ] fillarray 61,63,66,68,70
>> > But how can I check if inotnum is equal to one of the numbers in the
>> > array?
>> > I've tried it with:
>> >
>> > I've created an array with (some) black keys:
>> > iblackkeys[ ] fillarray 61,63,66,68,70
>> > But this (as I expected) does not work.
>> >
>> >
>> > 2014-05-20 9:53 GMT+02:00 Stefan Thomas :
>> >
>> >> Dear Rory,
>> >> I've tried it with Your idea of using an array.
>> >> I've created an array with (some) black keys:
>> >> iblackkeys[ ] fillarray 61,63,66,68,70
>> >>
>> >>
>> >>
>> >> 2014-05-19 18:10 GMT+02:00 Rory Walsh :
>> >>
>> >>> You could save the note numbers in an array? That wouldn't bloat the
>> >>> code too much.
>> >>>
>> >>> On 19 May 2014 17:06, Stefan Thomas 
>> >>> wrote:
>> >>> > Dear community,
>> >>> > I want to allocate two different sounds to different midi-keys.
>> >>> > My aim is to get one sound for the black and another sound for the
>> >>> > white
>> >>> > keys.
>> >>> > I've started with the following code which works.
>> >>> > But my question is:
>> >>> > Is the maybe a more confortabe way to do this? If I use my method
>> >>> > the
>> >>> > if
>> >>> > condition would be very long!
>> >>> > Here is my code:
>> >>> > 
>> >>> > 
>> >>> > -odac -Ma -m0d
>> >>> > 
>> >>> > ; ==============================================
>> >>> > 
>> >>> >
>> >>> > sr    =    44100
>> >>> > nchnls    =    2
>> >>> > 0dbfs    =    1
>> >>> > gisine ftgen 0,0,2^13, 10, 1
>> >>> > alwayson 1
>> >>> > massign 0, 1
>> >>> > instr 1
>> >>> >     iamp     ampmidi 0.2
>> >>> >     icps     cpsmidi
>> >>> >     inotnum    notnum
>> >>> >     iatt     = 0.01
>> >>> >     idur     = 3
>> >>> >     irel     = 0.1
>> >>> >     aenv     linsegr 0,iatt,1,idur,0,irel,0
>> >>> >     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>> >>> > (inotnum
>> >>> > == 65) ) then
>> >>> >     aout    poscil    aenv*iamp,icps
>> >>> >     else
>> >>> >     aout    rand    aenv*iamp
>> >>> >     endif
>> >>> >     outs    aout, aout
>> >>> > endin
>> >>> >
>> >>> > 
>> >>> > ; ==============================================
>> >>> > 
>> >>> >
>> >>> > 
>> >>> > 
>> >>> >
>> >>> >
>> >>> >
>> >>>
>> >>>
>> >>> Send bugs reports to
>> >>>         https://github.com/csound/csound/issues
>> >>> Discussions of bugs and features can be posted here
>> >>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>> >>> "unsubscribe
>> >>> csound"
>> >>>
>> >>>
>> >>>
>> >>
>> >
>>
>>
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>

Hi Stefan,

Actually, I'm not sure if that UDO would work as-is, it might return a
b-type (boolean) rather than an i-type.  It might work due to the lack
of type checking on xout, but whenever I can get to adding that type
checking, it'd fail.  You might try something like:

opcode is_black_key, i, i
   inotenum xin
   ival = inotenum % 12
   if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival == 10) then
     ival = 1
   else
     ival = 0
   endif

   xout ival
endop

That way the UDO will return either 1 or 0, depending on if it is a black key.

steven

On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
 wrote:
> Dear Steven,
> I assume the modulo operator (%) does the same like in pyhon, right?
> And I would like to understand:
> if ival is e.g. 2, what is the value of xout? Or will there by no output of
> the opcode?
>
>
> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>
>> An array would be a good generic solution.  For one specific to just
>> black-key or white key, you might want to write a UDO that checks if a
>> note num is a black key.  Something like:
>>
>> opcode is_black_key, i, i
>>    inotenum xin
>>    ival = inotenum % 12
>>    xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival == 10)
>> endop
>>
>>
>>
>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh  wrote:
>> > You could save the note numbers in an array? That wouldn't bloat the
>> > code too much.
>> >
>> > On 19 May 2014 17:06, Stefan Thomas  wrote:
>> >> Dear community,
>> >> I want to allocate two different sounds to different midi-keys.
>> >> My aim is to get one sound for the black and another sound for the
>> >> white
>> >> keys.
>> >> I've started with the following code which works.
>> >> But my question is:
>> >> Is the maybe a more confortabe way to do this? If I use my method the
>> >> if
>> >> condition would be very long!
>> >> Here is my code:
>> >> 
>> >> 
>> >> -odac -Ma -m0d
>> >> 
>> >> ; ==============================================
>> >> 
>> >>
>> >> sr    =    44100
>> >> nchnls    =    2
>> >> 0dbfs    =    1
>> >> gisine ftgen 0,0,2^13, 10, 1
>> >> alwayson 1
>> >> massign 0, 1
>> >> instr 1
>> >>     iamp     ampmidi 0.2
>> >>     icps     cpsmidi
>> >>     inotnum    notnum
>> >>     iatt     = 0.01
>> >>     idur     = 3
>> >>     irel     = 0.1
>> >>     aenv     linsegr 0,iatt,1,idur,0,irel,0
>> >>     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>> >> (inotnum
>> >> == 65) ) then
>> >>     aout    poscil    aenv*iamp,icps
>> >>     else
>> >>     aout    rand    aenv*iamp
>> >>     endif
>> >>     outs    aout, aout
>> >> endin
>> >>
>> >> 
>> >> ; ==============================================
>> >> 
>> >>
>> >> 
>> >> 
>> >>
>> >>
>> >>
>> >
>> >
>> > Send bugs reports to
>> >         https://github.com/csound/csound/issues
>> > Discussions of bugs and features can be posted here
>> > To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> > csound"
>> >
>> >
>> >
>>
>>
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>

so you use the note number input as index in the table ... very clever:



-nm0


giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
instr 1
iNotNum = p4
iBlack = giblack[iNotNum%12]
if iBlack == 1 then
prints "Midi Key %d is a black key!\n", iNotNum
else
prints "Midi Key %d is a white key!\n", iNotNum
endif
endin


i 1 0 .1 60
i . + . 61
i . + . 62
i . + . 63
i . + . 64
i . + . 65
i . + . 66
i . + . 67
i . + . 68
i . + . 69
i . + . 70
i . + . 71



i agree that this is the best (fastest) solution. thanks -
	joachm



Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
> I still think the use of an array or table is the obvious way as others
> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
> with table
> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
> No need for an UDO
> ==John ff
>
> Quoting Stefan Thomas :
>
>> Ok, I've got it! I will try Your code. Thanks a lot!
>>
>>
>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>
>>> Hi Stefan,
>>>
>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>> of type checking on xout, but whenever I can get to adding that type
>>> checking, it'd fail.  You might try something like:
>>>
>>> opcode is_black_key, i, i
>>>    inotenum xin
>>>    ival = inotenum % 12
>>>    if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>> 10) then
>>>      ival = 1
>>>    else
>>>      ival = 0
>>>    endif
>>>
>>>    xout ival
>>> endop
>>>
>>> That way the UDO will return either 1 or 0, depending on if it is a
>>> black
>>> key.
>>>
>>> steven
>>>
>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>  wrote:
>>> > Dear Steven,
>>> > I assume the modulo operator (%) does the same like in pyhon, right?
>>> > And I would like to understand:
>>> > if ival is e.g. 2, what is the value of xout? Or will there by no
>>> output
>>> of
>>> > the opcode?
>>> >
>>> >
>>> > 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>> >
>>> >> An array would be a good generic solution.  For one specific to just
>>> >> black-key or white key, you might want to write a UDO that checks
>>> if a
>>> >> note num is a black key.  Something like:
>>> >>
>>> >> opcode is_black_key, i, i
>>> >>    inotenum xin
>>> >>    ival = inotenum % 12
>>> >>    xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>> == 10)
>>> >> endop
>>> >>
>>> >>
>>> >>
>>> >> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>> wrote:
>>> >> > You could save the note numbers in an array? That wouldn't bloat
>>> the
>>> >> > code too much.
>>> >> >
>>> >> > On 19 May 2014 17:06, Stefan Thomas 
>>> wrote:
>>> >> >> Dear community,
>>> >> >> I want to allocate two different sounds to different midi-keys.
>>> >> >> My aim is to get one sound for the black and another sound for the
>>> >> >> white
>>> >> >> keys.
>>> >> >> I've started with the following code which works.
>>> >> >> But my question is:
>>> >> >> Is the maybe a more confortabe way to do this? If I use my
>>> method the
>>> >> >> if
>>> >> >> condition would be very long!
>>> >> >> Here is my code:
>>> >> >> 
>>> >> >> 
>>> >> >> -odac -Ma -m0d
>>> >> >> 
>>> >> >> ; ==============================================
>>> >> >> 
>>> >> >>
>>> >> >> sr    =    44100
>>> >> >> nchnls    =    2
>>> >> >> 0dbfs    =    1
>>> >> >> gisine ftgen 0,0,2^13, 10, 1
>>> >> >> alwayson 1
>>> >> >> massign 0, 1
>>> >> >> instr 1
>>> >> >>     iamp     ampmidi 0.2
>>> >> >>     icps     cpsmidi
>>> >> >>     inotnum    notnum
>>> >> >>     iatt     = 0.01
>>> >> >>     idur     = 3
>>> >> >>     irel     = 0.1
>>> >> >>     aenv     linsegr 0,iatt,1,idur,0,irel,0
>>> >> >>     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>> >> >> (inotnum
>>> >> >> == 65) ) then
>>> >> >>     aout    poscil    aenv*iamp,icps
>>> >> >>     else
>>> >> >>     aout    rand    aenv*iamp
>>> >> >>     endif
>>> >> >>     outs    aout, aout
>>> >> >> endin
>>> >> >>
>>> >> >> 
>>> >> >> ; ==============================================
>>> >> >> 
>>> >> >>
>>> >> >> 
>>> >> >> 
>>> >> >>
>>> >> >>
>>> >> >>
>>> >> >
>>> >> >
>>> >> > Send bugs reports to
>>> >> >         https://github.com/csound/csound/issues
>>> >> > Discussions of bugs and features can be posted here
>>> >> > To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>> "unsubscribe
>>> >> > csound"
>>> >> >
>>> >> >
>>> >> >
>>> >>
>>> >>
>>> >> Send bugs reports to
>>> >>         https://github.com/csound/csound/issues
>>> >> Discussions of bugs and features can be posted here
>>> >> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>> "unsubscribe
>>> >> csound"
>>> >>
>>> >>
>>> >>
>>> >
>>>
>>>
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>>>
>>
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>> "unsubscribe csound"
>
>
>
>
>
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
> csound"
>
>
>
>

That would make a nice addition to the sections on arrays in the floss manual.

On 21 May 2014 19:48, joachim heintz  wrote:
> so you use the note number input as index in the table ... very clever:
>
> 
> 
> -nm0
> 
> 
> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
> instr 1
> iNotNum = p4
> iBlack = giblack[iNotNum%12]
> if iBlack == 1 then
> prints "Midi Key %d is a black key!\n", iNotNum
> else
> prints "Midi Key %d is a white key!\n", iNotNum
> endif
> endin
> 
> 
> i 1 0 .1 60
> i . + . 61
> i . + . 62
> i . + . 63
> i . + . 64
> i . + . 65
> i . + . 66
> i . + . 67
> i . + . 68
> i . + . 69
> i . + . 70
> i . + . 71
> 
> 
>
> i agree that this is the best (fastest) solution. thanks -
>         joachm
>
>
>
> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>
>> I still think the use of an array or table is the obvious way as others
>> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
>> with table
>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>> No need for an UDO
>> ==John ff
>>
>> Quoting Stefan Thomas :
>>
>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>
>>>
>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>
>>>> Hi Stefan,
>>>>
>>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>>> of type checking on xout, but whenever I can get to adding that type
>>>> checking, it'd fail.  You might try something like:
>>>>
>>>> opcode is_black_key, i, i
>>>>    inotenum xin
>>>>    ival = inotenum % 12
>>>>    if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>>> 10) then
>>>>      ival = 1
>>>>    else
>>>>      ival = 0
>>>>    endif
>>>>
>>>>    xout ival
>>>> endop
>>>>
>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>> black
>>>> key.
>>>>
>>>> steven
>>>>
>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>  wrote:
>>>> > Dear Steven,
>>>> > I assume the modulo operator (%) does the same like in pyhon, right?
>>>> > And I would like to understand:
>>>> > if ival is e.g. 2, what is the value of xout? Or will there by no
>>>> output
>>>> of
>>>> > the opcode?
>>>> >
>>>> >
>>>> > 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>> >
>>>> >> An array would be a good generic solution.  For one specific to just
>>>> >> black-key or white key, you might want to write a UDO that checks
>>>> if a
>>>> >> note num is a black key.  Something like:
>>>> >>
>>>> >> opcode is_black_key, i, i
>>>> >>    inotenum xin
>>>> >>    ival = inotenum % 12
>>>> >>    xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>> == 10)
>>>> >> endop
>>>> >>
>>>> >>
>>>> >>
>>>> >> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>> wrote:
>>>> >> > You could save the note numbers in an array? That wouldn't bloat
>>>> the
>>>> >> > code too much.
>>>> >> >
>>>> >> > On 19 May 2014 17:06, Stefan Thomas 
>>>> wrote:
>>>> >> >> Dear community,
>>>> >> >> I want to allocate two different sounds to different midi-keys.
>>>> >> >> My aim is to get one sound for the black and another sound for the
>>>> >> >> white
>>>> >> >> keys.
>>>> >> >> I've started with the following code which works.
>>>> >> >> But my question is:
>>>> >> >> Is the maybe a more confortabe way to do this? If I use my
>>>> method the
>>>> >> >> if
>>>> >> >> condition would be very long!
>>>> >> >> Here is my code:
>>>> >> >> 
>>>> >> >> 
>>>> >> >> -odac -Ma -m0d
>>>> >> >> 
>>>> >> >> ; ==============================================
>>>> >> >> 
>>>> >> >>
>>>> >> >> sr    =    44100
>>>> >> >> nchnls    =    2
>>>> >> >> 0dbfs    =    1
>>>> >> >> gisine ftgen 0,0,2^13, 10, 1
>>>> >> >> alwayson 1
>>>> >> >> massign 0, 1
>>>> >> >> instr 1
>>>> >> >>     iamp     ampmidi 0.2
>>>> >> >>     icps     cpsmidi
>>>> >> >>     inotnum    notnum
>>>> >> >>     iatt     = 0.01
>>>> >> >>     idur     = 3
>>>> >> >>     irel     = 0.1
>>>> >> >>     aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>> >> >>     if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>>> >> >> (inotnum
>>>> >> >> == 65) ) then
>>>> >> >>     aout    poscil    aenv*iamp,icps
>>>> >> >>     else
>>>> >> >>     aout    rand    aenv*iamp
>>>> >> >>     endif
>>>> >> >>     outs    aout, aout
>>>> >> >> endin
>>>> >> >>
>>>> >> >> 
>>>> >> >> ; ==============================================
>>>> >> >> 
>>>> >> >>
>>>> >> >> 
>>>> >> >> 
>>>> >> >>
>>>> >> >>
>>>> >> >>
>>>> >> >
>>>> >> >
>>>> >> > Send bugs reports to
>>>> >> >         https://github.com/csound/csound/issues
>>>> >> > Discussions of bugs and features can be posted here
>>>> >> > To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>> "unsubscribe
>>>> >> > csound"
>>>> >> >
>>>> >> >
>>>> >> >
>>>> >>
>>>> >>
>>>> >> Send bugs reports to
>>>> >>         https://github.com/csound/csound/issues
>>>> >> Discussions of bugs and features can be posted here
>>>> >> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>> "unsubscribe
>>>> >> csound"
>>>> >>
>>>> >>
>>>> >>
>>>> >
>>>>
>>>>
>>>> Send bugs reports to
>>>>         https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>> csound"
>>>>
>>>>
>>>>
>>>>
>>>
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>> "unsubscribe csound"
>>
>>
>>
>>
>>
>>
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>>
>
>
> Send bugs reports to
>        https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
> csound"
>
>
>

right. and i bet you will beat me to add it ...
=)
	j


Am 21.05.2014 21:13, schrieb Rory Walsh:
> That would make a nice addition to the sections on arrays in the floss manual.
>
> On 21 May 2014 19:48, joachim heintz  wrote:
>> so you use the note number input as index in the table ... very clever:
>>
>> 
>> 
>> -nm0
>> 
>> 
>> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>> instr 1
>> iNotNum = p4
>> iBlack = giblack[iNotNum%12]
>> if iBlack == 1 then
>> prints "Midi Key %d is a black key!\n", iNotNum
>> else
>> prints "Midi Key %d is a white key!\n", iNotNum
>> endif
>> endin
>> 
>> 
>> i 1 0 .1 60
>> i . + . 61
>> i . + . 62
>> i . + . 63
>> i . + . 64
>> i . + . 65
>> i . + . 66
>> i . + . 67
>> i . + . 68
>> i . + . 69
>> i . + . 70
>> i . + . 71
>> 
>> 
>>
>> i agree that this is the best (fastest) solution. thanks -
>>          joachm
>>
>>
>>
>> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>>
>>> I still think the use of an array or table is the obvious way as others
>>> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
>>> with table
>>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>> No need for an UDO
>>> ==John ff
>>>
>>> Quoting Stefan Thomas :
>>>
>>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>>
>>>>
>>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>>
>>>>> Hi Stefan,
>>>>>
>>>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>>>> of type checking on xout, but whenever I can get to adding that type
>>>>> checking, it'd fail.  You might try something like:
>>>>>
>>>>> opcode is_black_key, i, i
>>>>>     inotenum xin
>>>>>     ival = inotenum % 12
>>>>>     if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>>>> 10) then
>>>>>       ival = 1
>>>>>     else
>>>>>       ival = 0
>>>>>     endif
>>>>>
>>>>>     xout ival
>>>>> endop
>>>>>
>>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>>> black
>>>>> key.
>>>>>
>>>>> steven
>>>>>
>>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>>  wrote:
>>>>>> Dear Steven,
>>>>>> I assume the modulo operator (%) does the same like in pyhon, right?
>>>>>> And I would like to understand:
>>>>>> if ival is e.g. 2, what is the value of xout? Or will there by no
>>>>> output
>>>>> of
>>>>>> the opcode?
>>>>>>
>>>>>>
>>>>>> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>>>>
>>>>>>> An array would be a good generic solution.  For one specific to just
>>>>>>> black-key or white key, you might want to write a UDO that checks
>>>>> if a
>>>>>>> note num is a black key.  Something like:
>>>>>>>
>>>>>>> opcode is_black_key, i, i
>>>>>>>     inotenum xin
>>>>>>>     ival = inotenum % 12
>>>>>>>     xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>>> == 10)
>>>>>>> endop
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>>> wrote:
>>>>>>>> You could save the note numbers in an array? That wouldn't bloat
>>>>> the
>>>>>>>> code too much.
>>>>>>>>
>>>>>>>> On 19 May 2014 17:06, Stefan Thomas 
>>>>> wrote:
>>>>>>>>> Dear community,
>>>>>>>>> I want to allocate two different sounds to different midi-keys.
>>>>>>>>> My aim is to get one sound for the black and another sound for the
>>>>>>>>> white
>>>>>>>>> keys.
>>>>>>>>> I've started with the following code which works.
>>>>>>>>> But my question is:
>>>>>>>>> Is the maybe a more confortabe way to do this? If I use my
>>>>> method the
>>>>>>>>> if
>>>>>>>>> condition would be very long!
>>>>>>>>> Here is my code:
>>>>>>>>> 
>>>>>>>>> 
>>>>>>>>> -odac -Ma -m0d
>>>>>>>>> 
>>>>>>>>> ; ==============================================
>>>>>>>>> 
>>>>>>>>>
>>>>>>>>> sr    =    44100
>>>>>>>>> nchnls    =    2
>>>>>>>>> 0dbfs    =    1
>>>>>>>>> gisine ftgen 0,0,2^13, 10, 1
>>>>>>>>> alwayson 1
>>>>>>>>> massign 0, 1
>>>>>>>>> instr 1
>>>>>>>>>      iamp     ampmidi 0.2
>>>>>>>>>      icps     cpsmidi
>>>>>>>>>      inotnum    notnum
>>>>>>>>>      iatt     = 0.01
>>>>>>>>>      idur     = 3
>>>>>>>>>      irel     = 0.1
>>>>>>>>>      aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>>>>>>>      if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>>>>>>>> (inotnum
>>>>>>>>> == 65) ) then
>>>>>>>>>      aout    poscil    aenv*iamp,icps
>>>>>>>>>      else
>>>>>>>>>      aout    rand    aenv*iamp
>>>>>>>>>      endif
>>>>>>>>>      outs    aout, aout
>>>>>>>>> endin
>>>>>>>>>
>>>>>>>>> 
>>>>>>>>> ; ==============================================
>>>>>>>>> 
>>>>>>>>>
>>>>>>>>> 
>>>>>>>>> 
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Send bugs reports to
>>>>>>>>          https://github.com/csound/csound/issues
>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>> "unsubscribe
>>>>>>>> csound"
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Send bugs reports to
>>>>>>>          https://github.com/csound/csound/issues
>>>>>>> Discussions of bugs and features can be posted here
>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>> "unsubscribe
>>>>>>> csound"
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> Send bugs reports to
>>>>>          https://github.com/csound/csound/issues
>>>>> Discussions of bugs and features can be posted here
>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>>> csound"
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>> Send bugs reports to
>>>>          https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>> "unsubscribe csound"
>>>
>>>
>>>
>>>
>>>
>>>
>>> Send bugs reports to
>>>          https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>>>
>>
>>
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>
>
> Send bugs reports to
>          https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>
>
>
>

I walked right in to that one!

On 21 May 2014 20:41, joachim heintz  wrote:
> right. and i bet you will beat me to add it ...
> =)
>         j
>
>
> Am 21.05.2014 21:13, schrieb Rory Walsh:
>
>> That would make a nice addition to the sections on arrays in the floss
>> manual.
>>
>> On 21 May 2014 19:48, joachim heintz  wrote:
>>>
>>> so you use the note number input as index in the table ... very clever:
>>>
>>> 
>>> 
>>> -nm0
>>> 
>>> 
>>> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>> instr 1
>>> iNotNum = p4
>>> iBlack = giblack[iNotNum%12]
>>> if iBlack == 1 then
>>> prints "Midi Key %d is a black key!\n", iNotNum
>>> else
>>> prints "Midi Key %d is a white key!\n", iNotNum
>>> endif
>>> endin
>>> 
>>> 
>>> i 1 0 .1 60
>>> i . + . 61
>>> i . + . 62
>>> i . + . 63
>>> i . + . 64
>>> i . + . 65
>>> i . + . 66
>>> i . + . 67
>>> i . + . 68
>>> i . + . 69
>>> i . + . 70
>>> i . + . 71
>>> 
>>> 
>>>
>>> i agree that this is the best (fastest) solution. thanks -
>>>          joachm
>>>
>>>
>>>
>>> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>>>
>>>>
>>>> I still think the use of an array or table is the obvious way as others
>>>> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
>>>> with table
>>>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>> No need for an UDO
>>>> ==John ff
>>>>
>>>> Quoting Stefan Thomas :
>>>>
>>>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>>>
>>>>>
>>>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>>>
>>>>>> Hi Stefan,
>>>>>>
>>>>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>>>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>>>>> of type checking on xout, but whenever I can get to adding that type
>>>>>> checking, it'd fail.  You might try something like:
>>>>>>
>>>>>> opcode is_black_key, i, i
>>>>>>     inotenum xin
>>>>>>     ival = inotenum % 12
>>>>>>     if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>>>>> 10) then
>>>>>>       ival = 1
>>>>>>     else
>>>>>>       ival = 0
>>>>>>     endif
>>>>>>
>>>>>>     xout ival
>>>>>> endop
>>>>>>
>>>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>>>> black
>>>>>> key.
>>>>>>
>>>>>> steven
>>>>>>
>>>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>>>  wrote:
>>>>>>>
>>>>>>> Dear Steven,
>>>>>>> I assume the modulo operator (%) does the same like in pyhon, right?
>>>>>>> And I would like to understand:
>>>>>>> if ival is e.g. 2, what is the value of xout? Or will there by no
>>>>>>
>>>>>> output
>>>>>> of
>>>>>>>
>>>>>>> the opcode?
>>>>>>>
>>>>>>>
>>>>>>> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>>>>>
>>>>>>>> An array would be a good generic solution.  For one specific to just
>>>>>>>> black-key or white key, you might want to write a UDO that checks
>>>>>>
>>>>>> if a
>>>>>>>>
>>>>>>>> note num is a black key.  Something like:
>>>>>>>>
>>>>>>>> opcode is_black_key, i, i
>>>>>>>>     inotenum xin
>>>>>>>>     ival = inotenum % 12
>>>>>>>>     xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>>>>
>>>>>> == 10)
>>>>>>>>
>>>>>>>> endop
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>>>>
>>>>>> wrote:
>>>>>>>>>
>>>>>>>>> You could save the note numbers in an array? That wouldn't bloat
>>>>>>
>>>>>> the
>>>>>>>>>
>>>>>>>>> code too much.
>>>>>>>>>
>>>>>>>>> On 19 May 2014 17:06, Stefan Thomas 
>>>>>>
>>>>>> wrote:
>>>>>>>>>>
>>>>>>>>>> Dear community,
>>>>>>>>>> I want to allocate two different sounds to different midi-keys.
>>>>>>>>>> My aim is to get one sound for the black and another sound for the
>>>>>>>>>> white
>>>>>>>>>> keys.
>>>>>>>>>> I've started with the following code which works.
>>>>>>>>>> But my question is:
>>>>>>>>>> Is the maybe a more confortabe way to do this? If I use my
>>>>>>
>>>>>> method the
>>>>>>>>>>
>>>>>>>>>> if
>>>>>>>>>> condition would be very long!
>>>>>>>>>> Here is my code:
>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>>> -odac -Ma -m0d
>>>>>>>>>> 
>>>>>>>>>> ; ==============================================
>>>>>>>>>> 
>>>>>>>>>>
>>>>>>>>>> sr    =    44100
>>>>>>>>>> nchnls    =    2
>>>>>>>>>> 0dbfs    =    1
>>>>>>>>>> gisine ftgen 0,0,2^13, 10, 1
>>>>>>>>>> alwayson 1
>>>>>>>>>> massign 0, 1
>>>>>>>>>> instr 1
>>>>>>>>>>      iamp     ampmidi 0.2
>>>>>>>>>>      icps     cpsmidi
>>>>>>>>>>      inotnum    notnum
>>>>>>>>>>      iatt     = 0.01
>>>>>>>>>>      idur     = 3
>>>>>>>>>>      irel     = 0.1
>>>>>>>>>>      aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>>>>>>>>      if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>>>>>>>>> (inotnum
>>>>>>>>>> == 65) ) then
>>>>>>>>>>      aout    poscil    aenv*iamp,icps
>>>>>>>>>>      else
>>>>>>>>>>      aout    rand    aenv*iamp
>>>>>>>>>>      endif
>>>>>>>>>>      outs    aout, aout
>>>>>>>>>> endin
>>>>>>>>>>
>>>>>>>>>> 
>>>>>>>>>> ; ==============================================
>>>>>>>>>> 
>>>>>>>>>>
>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Send bugs reports to
>>>>>>>>>          https://github.com/csound/csound/issues
>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>
>>>>>> "unsubscribe
>>>>>>>>>
>>>>>>>>> csound"
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Send bugs reports to
>>>>>>>>          https://github.com/csound/csound/issues
>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>
>>>>>> "unsubscribe
>>>>>>>>
>>>>>>>> csound"
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Send bugs reports to
>>>>>>          https://github.com/csound/csound/issues
>>>>>> Discussions of bugs and features can be posted here
>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>> "unsubscribe
>>>>>> csound"
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Send bugs reports to
>>>>>          https://github.com/csound/csound/issues
>>>>> Discussions of bugs and features can be posted here
>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>> "unsubscribe csound"
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> Send bugs reports to
>>>>          https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>> csound"
>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>>
>>
>> Send bugs reports to
>>          https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>>
>
>
> Send bugs reports to
>        https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
> csound"
>
>
>

I'm getting strange behavior when I log into floss? Can you access
chapter at the moment?

On 21 May 2014 20:47, Rory Walsh  wrote:
> I walked right in to that one!
>
> On 21 May 2014 20:41, joachim heintz  wrote:
>> right. and i bet you will beat me to add it ...
>> =)
>>         j
>>
>>
>> Am 21.05.2014 21:13, schrieb Rory Walsh:
>>
>>> That would make a nice addition to the sections on arrays in the floss
>>> manual.
>>>
>>> On 21 May 2014 19:48, joachim heintz  wrote:
>>>>
>>>> so you use the note number input as index in the table ... very clever:
>>>>
>>>> 
>>>> 
>>>> -nm0
>>>> 
>>>> 
>>>> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>> instr 1
>>>> iNotNum = p4
>>>> iBlack = giblack[iNotNum%12]
>>>> if iBlack == 1 then
>>>> prints "Midi Key %d is a black key!\n", iNotNum
>>>> else
>>>> prints "Midi Key %d is a white key!\n", iNotNum
>>>> endif
>>>> endin
>>>> 
>>>> 
>>>> i 1 0 .1 60
>>>> i . + . 61
>>>> i . + . 62
>>>> i . + . 63
>>>> i . + . 64
>>>> i . + . 65
>>>> i . + . 66
>>>> i . + . 67
>>>> i . + . 68
>>>> i . + . 69
>>>> i . + . 70
>>>> i . + . 71
>>>> 
>>>> 
>>>>
>>>> i agree that this is the best (fastest) solution. thanks -
>>>>          joachm
>>>>
>>>>
>>>>
>>>> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>>>>
>>>>>
>>>>> I still think the use of an array or table is the obvious way as others
>>>>> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
>>>>> with table
>>>>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>>> No need for an UDO
>>>>> ==John ff
>>>>>
>>>>> Quoting Stefan Thomas :
>>>>>
>>>>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>>>>
>>>>>>
>>>>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>>>>
>>>>>>> Hi Stefan,
>>>>>>>
>>>>>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>>>>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>>>>>> of type checking on xout, but whenever I can get to adding that type
>>>>>>> checking, it'd fail.  You might try something like:
>>>>>>>
>>>>>>> opcode is_black_key, i, i
>>>>>>>     inotenum xin
>>>>>>>     ival = inotenum % 12
>>>>>>>     if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>>>>>> 10) then
>>>>>>>       ival = 1
>>>>>>>     else
>>>>>>>       ival = 0
>>>>>>>     endif
>>>>>>>
>>>>>>>     xout ival
>>>>>>> endop
>>>>>>>
>>>>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>>>>> black
>>>>>>> key.
>>>>>>>
>>>>>>> steven
>>>>>>>
>>>>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>>>>  wrote:
>>>>>>>>
>>>>>>>> Dear Steven,
>>>>>>>> I assume the modulo operator (%) does the same like in pyhon, right?
>>>>>>>> And I would like to understand:
>>>>>>>> if ival is e.g. 2, what is the value of xout? Or will there by no
>>>>>>>
>>>>>>> output
>>>>>>> of
>>>>>>>>
>>>>>>>> the opcode?
>>>>>>>>
>>>>>>>>
>>>>>>>> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>>>>>>
>>>>>>>>> An array would be a good generic solution.  For one specific to just
>>>>>>>>> black-key or white key, you might want to write a UDO that checks
>>>>>>>
>>>>>>> if a
>>>>>>>>>
>>>>>>>>> note num is a black key.  Something like:
>>>>>>>>>
>>>>>>>>> opcode is_black_key, i, i
>>>>>>>>>     inotenum xin
>>>>>>>>>     ival = inotenum % 12
>>>>>>>>>     xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>>>>>
>>>>>>> == 10)
>>>>>>>>>
>>>>>>>>> endop
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>>>>>
>>>>>>> wrote:
>>>>>>>>>>
>>>>>>>>>> You could save the note numbers in an array? That wouldn't bloat
>>>>>>>
>>>>>>> the
>>>>>>>>>>
>>>>>>>>>> code too much.
>>>>>>>>>>
>>>>>>>>>> On 19 May 2014 17:06, Stefan Thomas 
>>>>>>>
>>>>>>> wrote:
>>>>>>>>>>>
>>>>>>>>>>> Dear community,
>>>>>>>>>>> I want to allocate two different sounds to different midi-keys.
>>>>>>>>>>> My aim is to get one sound for the black and another sound for the
>>>>>>>>>>> white
>>>>>>>>>>> keys.
>>>>>>>>>>> I've started with the following code which works.
>>>>>>>>>>> But my question is:
>>>>>>>>>>> Is the maybe a more confortabe way to do this? If I use my
>>>>>>>
>>>>>>> method the
>>>>>>>>>>>
>>>>>>>>>>> if
>>>>>>>>>>> condition would be very long!
>>>>>>>>>>> Here is my code:
>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>> -odac -Ma -m0d
>>>>>>>>>>> 
>>>>>>>>>>> ; ==============================================
>>>>>>>>>>> 
>>>>>>>>>>>
>>>>>>>>>>> sr    =    44100
>>>>>>>>>>> nchnls    =    2
>>>>>>>>>>> 0dbfs    =    1
>>>>>>>>>>> gisine ftgen 0,0,2^13, 10, 1
>>>>>>>>>>> alwayson 1
>>>>>>>>>>> massign 0, 1
>>>>>>>>>>> instr 1
>>>>>>>>>>>      iamp     ampmidi 0.2
>>>>>>>>>>>      icps     cpsmidi
>>>>>>>>>>>      inotnum    notnum
>>>>>>>>>>>      iatt     = 0.01
>>>>>>>>>>>      idur     = 3
>>>>>>>>>>>      irel     = 0.1
>>>>>>>>>>>      aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>>>>>>>>>      if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>>>>>>>>>> (inotnum
>>>>>>>>>>> == 65) ) then
>>>>>>>>>>>      aout    poscil    aenv*iamp,icps
>>>>>>>>>>>      else
>>>>>>>>>>>      aout    rand    aenv*iamp
>>>>>>>>>>>      endif
>>>>>>>>>>>      outs    aout, aout
>>>>>>>>>>> endin
>>>>>>>>>>>
>>>>>>>>>>> 
>>>>>>>>>>> ; ==============================================
>>>>>>>>>>> 
>>>>>>>>>>>
>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Send bugs reports to
>>>>>>>>>>          https://github.com/csound/csound/issues
>>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>
>>>>>>> "unsubscribe
>>>>>>>>>>
>>>>>>>>>> csound"
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Send bugs reports to
>>>>>>>>>          https://github.com/csound/csound/issues
>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>
>>>>>>> "unsubscribe
>>>>>>>>>
>>>>>>>>> csound"
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Send bugs reports to
>>>>>>>          https://github.com/csound/csound/issues
>>>>>>> Discussions of bugs and features can be posted here
>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>> "unsubscribe
>>>>>>> csound"
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Send bugs reports to
>>>>>>          https://github.com/csound/csound/issues
>>>>>> Discussions of bugs and features can be posted here
>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>> "unsubscribe csound"
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> Send bugs reports to
>>>>>          https://github.com/csound/csound/issues
>>>>> Discussions of bugs and features can be posted here
>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>>> csound"
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> Send bugs reports to
>>>>         https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>> csound"
>>>>
>>>>
>>>>
>>>
>>>
>>> Send bugs reports to
>>>          https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>>>
>>
>>
>> Send bugs reports to
>>        https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>

yes, i can. what is the strange behaviour? did you disable ad blocker 
for this site?


Am 21.05.2014 21:52, schrieb Rory Walsh:
> I'm getting strange behavior when I log into floss? Can you access
> chapter at the moment?
>
> On 21 May 2014 20:47, Rory Walsh  wrote:
>> I walked right in to that one!
>>
>> On 21 May 2014 20:41, joachim heintz  wrote:
>>> right. and i bet you will beat me to add it ...
>>> =)
>>>          j
>>>
>>>
>>> Am 21.05.2014 21:13, schrieb Rory Walsh:
>>>
>>>> That would make a nice addition to the sections on arrays in the floss
>>>> manual.
>>>>
>>>> On 21 May 2014 19:48, joachim heintz  wrote:
>>>>>
>>>>> so you use the note number input as index in the table ... very clever:
>>>>>
>>>>> 
>>>>> 
>>>>> -nm0
>>>>> 
>>>>> 
>>>>> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>>> instr 1
>>>>> iNotNum = p4
>>>>> iBlack = giblack[iNotNum%12]
>>>>> if iBlack == 1 then
>>>>> prints "Midi Key %d is a black key!\n", iNotNum
>>>>> else
>>>>> prints "Midi Key %d is a white key!\n", iNotNum
>>>>> endif
>>>>> endin
>>>>> 
>>>>> 
>>>>> i 1 0 .1 60
>>>>> i . + . 61
>>>>> i . + . 62
>>>>> i . + . 63
>>>>> i . + . 64
>>>>> i . + . 65
>>>>> i . + . 66
>>>>> i . + . 67
>>>>> i . + . 68
>>>>> i . + . 69
>>>>> i . + . 70
>>>>> i . + . 71
>>>>> 
>>>>> 
>>>>>
>>>>> i agree that this is the best (fastest) solution. thanks -
>>>>>           joachm
>>>>>
>>>>>
>>>>>
>>>>> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>>>>>
>>>>>>
>>>>>> I still think the use of an array or table is the obvious way as others
>>>>>> suggested.  Then one lookup like iblack[inotenum % 12] gives the result
>>>>>> with table
>>>>>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>>>> No need for an UDO
>>>>>> ==John ff
>>>>>>
>>>>>> Quoting Stefan Thomas :
>>>>>>
>>>>>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>>>>>
>>>>>>>
>>>>>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>>>>>
>>>>>>>> Hi Stefan,
>>>>>>>>
>>>>>>>> Actually, I'm not sure if that UDO would work as-is, it might return a
>>>>>>>> b-type (boolean) rather than an i-type.  It might work due to the lack
>>>>>>>> of type checking on xout, but whenever I can get to adding that type
>>>>>>>> checking, it'd fail.  You might try something like:
>>>>>>>>
>>>>>>>> opcode is_black_key, i, i
>>>>>>>>      inotenum xin
>>>>>>>>      ival = inotenum % 12
>>>>>>>>      if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival ==
>>>>>>>> 10) then
>>>>>>>>        ival = 1
>>>>>>>>      else
>>>>>>>>        ival = 0
>>>>>>>>      endif
>>>>>>>>
>>>>>>>>      xout ival
>>>>>>>> endop
>>>>>>>>
>>>>>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>>>>>> black
>>>>>>>> key.
>>>>>>>>
>>>>>>>> steven
>>>>>>>>
>>>>>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>>>>>  wrote:
>>>>>>>>>
>>>>>>>>> Dear Steven,
>>>>>>>>> I assume the modulo operator (%) does the same like in pyhon, right?
>>>>>>>>> And I would like to understand:
>>>>>>>>> if ival is e.g. 2, what is the value of xout? Or will there by no
>>>>>>>>
>>>>>>>> output
>>>>>>>> of
>>>>>>>>>
>>>>>>>>> the opcode?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>>>>>>>
>>>>>>>>>> An array would be a good generic solution.  For one specific to just
>>>>>>>>>> black-key or white key, you might want to write a UDO that checks
>>>>>>>>
>>>>>>>> if a
>>>>>>>>>>
>>>>>>>>>> note num is a black key.  Something like:
>>>>>>>>>>
>>>>>>>>>> opcode is_black_key, i, i
>>>>>>>>>>      inotenum xin
>>>>>>>>>>      ival = inotenum % 12
>>>>>>>>>>      xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>>>>>>
>>>>>>>> == 10)
>>>>>>>>>>
>>>>>>>>>> endop
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>>>>>>
>>>>>>>> wrote:
>>>>>>>>>>>
>>>>>>>>>>> You could save the note numbers in an array? That wouldn't bloat
>>>>>>>>
>>>>>>>> the
>>>>>>>>>>>
>>>>>>>>>>> code too much.
>>>>>>>>>>>
>>>>>>>>>>> On 19 May 2014 17:06, Stefan Thomas 
>>>>>>>>
>>>>>>>> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> Dear community,
>>>>>>>>>>>> I want to allocate two different sounds to different midi-keys.
>>>>>>>>>>>> My aim is to get one sound for the black and another sound for the
>>>>>>>>>>>> white
>>>>>>>>>>>> keys.
>>>>>>>>>>>> I've started with the following code which works.
>>>>>>>>>>>> But my question is:
>>>>>>>>>>>> Is the maybe a more confortabe way to do this? If I use my
>>>>>>>>
>>>>>>>> method the
>>>>>>>>>>>>
>>>>>>>>>>>> if
>>>>>>>>>>>> condition would be very long!
>>>>>>>>>>>> Here is my code:
>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>> -odac -Ma -m0d
>>>>>>>>>>>> 
>>>>>>>>>>>> ; ==============================================
>>>>>>>>>>>> 
>>>>>>>>>>>>
>>>>>>>>>>>> sr    =    44100
>>>>>>>>>>>> nchnls    =    2
>>>>>>>>>>>> 0dbfs    =    1
>>>>>>>>>>>> gisine ftgen 0,0,2^13, 10, 1
>>>>>>>>>>>> alwayson 1
>>>>>>>>>>>> massign 0, 1
>>>>>>>>>>>> instr 1
>>>>>>>>>>>>       iamp     ampmidi 0.2
>>>>>>>>>>>>       icps     cpsmidi
>>>>>>>>>>>>       inotnum    notnum
>>>>>>>>>>>>       iatt     = 0.01
>>>>>>>>>>>>       idur     = 3
>>>>>>>>>>>>       irel     = 0.1
>>>>>>>>>>>>       aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>>>>>>>>>>       if ( (inotnum == 60) || (inotnum == 62) || (inotnum == 64) ||
>>>>>>>>>>>> (inotnum
>>>>>>>>>>>> == 65) ) then
>>>>>>>>>>>>       aout    poscil    aenv*iamp,icps
>>>>>>>>>>>>       else
>>>>>>>>>>>>       aout    rand    aenv*iamp
>>>>>>>>>>>>       endif
>>>>>>>>>>>>       outs    aout, aout
>>>>>>>>>>>> endin
>>>>>>>>>>>>
>>>>>>>>>>>> 
>>>>>>>>>>>> ; ==============================================
>>>>>>>>>>>> 
>>>>>>>>>>>>
>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Send bugs reports to
>>>>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>>
>>>>>>>> "unsubscribe
>>>>>>>>>>>
>>>>>>>>>>> csound"
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Send bugs reports to
>>>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>>
>>>>>>>> "unsubscribe
>>>>>>>>>>
>>>>>>>>>> csound"
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Send bugs reports to
>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>> "unsubscribe
>>>>>>>> csound"
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Send bugs reports to
>>>>>>>           https://github.com/csound/csound/issues
>>>>>>> Discussions of bugs and features can be posted here
>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>> "unsubscribe csound"
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> Send bugs reports to
>>>>>>           https://github.com/csound/csound/issues
>>>>>> Discussions of bugs and features can be posted here
>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>>>> csound"
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> Send bugs reports to
>>>>>          https://github.com/csound/csound/issues
>>>>> Discussions of bugs and features can be posted here
>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>>> csound"
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> Send bugs reports to
>>>>           https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>> csound"
>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>> csound"
>>>
>>>
>>>
>
>
> Send bugs reports to
>          https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>
>
>
>

That could be it. Thanks, I'll try that.

On 22 May 2014 19:05, joachim heintz  wrote:
> yes, i can. what is the strange behaviour? did you disable ad blocker for
> this site?
>
>
> Am 21.05.2014 21:52, schrieb Rory Walsh:
>>
>> I'm getting strange behavior when I log into floss? Can you access
>> chapter at the moment?
>>
>> On 21 May 2014 20:47, Rory Walsh  wrote:
>>>
>>> I walked right in to that one!
>>>
>>> On 21 May 2014 20:41, joachim heintz  wrote:
>>>>
>>>> right. and i bet you will beat me to add it ...
>>>> =)
>>>>          j
>>>>
>>>>
>>>> Am 21.05.2014 21:13, schrieb Rory Walsh:
>>>>
>>>>> That would make a nice addition to the sections on arrays in the floss
>>>>> manual.
>>>>>
>>>>> On 21 May 2014 19:48, joachim heintz  wrote:
>>>>>>
>>>>>>
>>>>>> so you use the note number input as index in the table ... very
>>>>>> clever:
>>>>>>
>>>>>> 
>>>>>> 
>>>>>> -nm0
>>>>>> 
>>>>>> 
>>>>>> giblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>>>> instr 1
>>>>>> iNotNum = p4
>>>>>> iBlack = giblack[iNotNum%12]
>>>>>> if iBlack == 1 then
>>>>>> prints "Midi Key %d is a black key!\n", iNotNum
>>>>>> else
>>>>>> prints "Midi Key %d is a white key!\n", iNotNum
>>>>>> endif
>>>>>> endin
>>>>>> 
>>>>>> 
>>>>>> i 1 0 .1 60
>>>>>> i . + . 61
>>>>>> i . + . 62
>>>>>> i . + . 63
>>>>>> i . + . 64
>>>>>> i . + . 65
>>>>>> i . + . 66
>>>>>> i . + . 67
>>>>>> i . + . 68
>>>>>> i . + . 69
>>>>>> i . + . 70
>>>>>> i . + . 71
>>>>>> 
>>>>>> 
>>>>>>
>>>>>> i agree that this is the best (fastest) solution. thanks -
>>>>>>           joachm
>>>>>>
>>>>>>
>>>>>>
>>>>>> Am 21.05.2014 10:34, schrieb jpff@cs.bath.ac.uk:
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> I still think the use of an array or table is the obvious way as
>>>>>>> others
>>>>>>> suggested.  Then one lookup like iblack[inotenum % 12] gives the
>>>>>>> result
>>>>>>> with table
>>>>>>> iblack[] fillarray 0,1,0,1,0,0,1,0,1,0,1,0
>>>>>>> No need for an UDO
>>>>>>> ==John ff
>>>>>>>
>>>>>>> Quoting Stefan Thomas :
>>>>>>>
>>>>>>>> Ok, I've got it! I will try Your code. Thanks a lot!
>>>>>>>>
>>>>>>>>
>>>>>>>> 2014-05-20 21:24 GMT+02:00 Steven Yi :
>>>>>>>>
>>>>>>>>> Hi Stefan,
>>>>>>>>>
>>>>>>>>> Actually, I'm not sure if that UDO would work as-is, it might
>>>>>>>>> return a
>>>>>>>>> b-type (boolean) rather than an i-type.  It might work due to the
>>>>>>>>> lack
>>>>>>>>> of type checking on xout, but whenever I can get to adding that
>>>>>>>>> type
>>>>>>>>> checking, it'd fail.  You might try something like:
>>>>>>>>>
>>>>>>>>> opcode is_black_key, i, i
>>>>>>>>>      inotenum xin
>>>>>>>>>      ival = inotenum % 12
>>>>>>>>>      if (ival == 1 || ival == 3 || ival == 6 || ival == 8 || ival
>>>>>>>>> ==
>>>>>>>>> 10) then
>>>>>>>>>        ival = 1
>>>>>>>>>      else
>>>>>>>>>        ival = 0
>>>>>>>>>      endif
>>>>>>>>>
>>>>>>>>>      xout ival
>>>>>>>>> endop
>>>>>>>>>
>>>>>>>>> That way the UDO will return either 1 or 0, depending on if it is a
>>>>>>>>> black
>>>>>>>>> key.
>>>>>>>>>
>>>>>>>>> steven
>>>>>>>>>
>>>>>>>>> On Tue, May 20, 2014 at 3:17 PM, Stefan Thomas
>>>>>>>>>  wrote:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Dear Steven,
>>>>>>>>>> I assume the modulo operator (%) does the same like in pyhon,
>>>>>>>>>> right?
>>>>>>>>>> And I would like to understand:
>>>>>>>>>> if ival is e.g. 2, what is the value of xout? Or will there by no
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> output
>>>>>>>>> of
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> the opcode?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 2014-05-19 18:22 GMT+02:00 Steven Yi :
>>>>>>>>>>
>>>>>>>>>>> An array would be a good generic solution.  For one specific to
>>>>>>>>>>> just
>>>>>>>>>>> black-key or white key, you might want to write a UDO that checks
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> if a
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> note num is a black key.  Something like:
>>>>>>>>>>>
>>>>>>>>>>> opcode is_black_key, i, i
>>>>>>>>>>>      inotenum xin
>>>>>>>>>>>      ival = inotenum % 12
>>>>>>>>>>>      xout (ival == 1 || ival == 3 || ival == 6 || ival == 8 ||
>>>>>>>>>>> ival
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> == 10)
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> endop
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> On Mon, May 19, 2014 at 12:10 PM, Rory Walsh 
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You could save the note numbers in an array? That wouldn't bloat
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> the
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> code too much.
>>>>>>>>>>>>
>>>>>>>>>>>> On 19 May 2014 17:06, Stefan Thomas
>>>>>>>>>>>> 
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Dear community,
>>>>>>>>>>>>> I want to allocate two different sounds to different midi-keys.
>>>>>>>>>>>>> My aim is to get one sound for the black and another sound for
>>>>>>>>>>>>> the
>>>>>>>>>>>>> white
>>>>>>>>>>>>> keys.
>>>>>>>>>>>>> I've started with the following code which works.
>>>>>>>>>>>>> But my question is:
>>>>>>>>>>>>> Is the maybe a more confortabe way to do this? If I use my
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> method the
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> if
>>>>>>>>>>>>> condition would be very long!
>>>>>>>>>>>>> Here is my code:
>>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>>> -odac -Ma -m0d
>>>>>>>>>>>>> 
>>>>>>>>>>>>> ; ==============================================
>>>>>>>>>>>>> 
>>>>>>>>>>>>>
>>>>>>>>>>>>> sr    =    44100
>>>>>>>>>>>>> nchnls    =    2
>>>>>>>>>>>>> 0dbfs    =    1
>>>>>>>>>>>>> gisine ftgen 0,0,2^13, 10, 1
>>>>>>>>>>>>> alwayson 1
>>>>>>>>>>>>> massign 0, 1
>>>>>>>>>>>>> instr 1
>>>>>>>>>>>>>       iamp     ampmidi 0.2
>>>>>>>>>>>>>       icps     cpsmidi
>>>>>>>>>>>>>       inotnum    notnum
>>>>>>>>>>>>>       iatt     = 0.01
>>>>>>>>>>>>>       idur     = 3
>>>>>>>>>>>>>       irel     = 0.1
>>>>>>>>>>>>>       aenv     linsegr 0,iatt,1,idur,0,irel,0
>>>>>>>>>>>>>       if ( (inotnum == 60) || (inotnum == 62) || (inotnum ==
>>>>>>>>>>>>> 64) ||
>>>>>>>>>>>>> (inotnum
>>>>>>>>>>>>> == 65) ) then
>>>>>>>>>>>>>       aout    poscil    aenv*iamp,icps
>>>>>>>>>>>>>       else
>>>>>>>>>>>>>       aout    rand    aenv*iamp
>>>>>>>>>>>>>       endif
>>>>>>>>>>>>>       outs    aout, aout
>>>>>>>>>>>>> endin
>>>>>>>>>>>>>
>>>>>>>>>>>>> 
>>>>>>>>>>>>> ; ==============================================
>>>>>>>>>>>>> 
>>>>>>>>>>>>>
>>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Send bugs reports to
>>>>>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> "unsubscribe
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> csound"
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Send bugs reports to
>>>>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> "unsubscribe
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> csound"
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Send bugs reports to
>>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>>> "unsubscribe
>>>>>>>>> csound"
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Send bugs reports to
>>>>>>>>           https://github.com/csound/csound/issues
>>>>>>>> Discussions of bugs and features can be posted here
>>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>>> "unsubscribe csound"
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Send bugs reports to
>>>>>>>           https://github.com/csound/csound/issues
>>>>>>> Discussions of bugs and features can be posted here
>>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>>> "unsubscribe
>>>>>>> csound"
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Send bugs reports to
>>>>>>          https://github.com/csound/csound/issues
>>>>>> Discussions of bugs and features can be posted here
>>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>>> "unsubscribe
>>>>>> csound"
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> Send bugs reports to
>>>>>           https://github.com/csound/csound/issues
>>>>> Discussions of bugs and features can be posted here
>>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body
>>>>> "unsubscribe
>>>>> csound"
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> Send bugs reports to
>>>>         https://github.com/csound/csound/issues
>>>> Discussions of bugs and features can be posted here
>>>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>>>> csound"
>>>>
>>>>
>>>>
>>
>>
>> Send bugs reports to
>>          https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
>> csound"
>>
>>
>>
>>
>
>
> Send bugs reports to
>        https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe
> csound"
>
>
>