Musical scale: Difference between revisions

[[Category:Temporal media]]

{{omit from|BASIC}}

 

;Task:

 

 

 

 

 

 

=={{header|AmigaBASIC}}==

 

READ f

SOUND f,10

NEXT

 

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

 

=={{header|BASIC256}}==

 

=={{header|Befunge}}==

The tune to be played is specified on the first line of the code. The notes are specified as MIDI note numbers in reverse order in a Befunge string (for example, ''Middle C'' is note number 60, which is the character "<"). This is followed by the count of notes in the string - 8 in this example.

 

v0*73"MThd"0006010101"MTrk"000<

>>#1-#,:#\_$8*74++,0,28*"'"039v

v,:,\,*2,1"Hd":\<,,,,,,*3"U"*9<

 

=={{header|C}}==

It is therefore essential to call nosound() at the end which ends the speaker output, otherwise the Turbo C (DOS) session will have to be ended.

 

#include<stdio.h>

#include<conio.h>

nosound();

return 0;

 

===Windows C===

Beep() can only play integer frequencies and thus the tones are noticeably lower than the ones played by sound() above.

 

#include<windows.h>

#include<stdio.h>

}

return 0;

 

=={{header|C++}}==

Uses Windows MIDI device

#include <iostream>

#include <windows.h>

return 0;

}

 

=={{header|Clojure}}==

{{libheader|Overtone}}

 

; Define your desired instrument

(Thread/sleep ms))

 

 

=={{header|EasyLang}}==

 

sleep 0.6

 

=={{header|Forth}}==

As a low level stack language Forth programming methodology prefers short simple definitions that extend the language in the direction that allows you to solve the problem. The creation of application specific language is common in Forth.

This demonstration code uses the PC speaker to generate musical tones. A simple device driver is created for hardware control via PORT I/O. A set of primitive operations are created to control the on:off times of the sounds. Then a small MUSIC language is created to create notes of different types. Finally 2 scales are created using "crotcheted notes" as they are called. We chose 1/8 notes. For fun we added the ability to change the expression of the notes using Italian musical terms.

\ PC speaker hardware control (requires giveio or DOSBOX for windows operation)

042 constant fctrl 061 constant sctrl

: Cmajor 1/8 C3 D3 E3 F3 G3 A3 B3 C4 ;

: Chromatic 1/8 C3 C#3 D3 D#3 E3 F3 F#3 G3 G#3 A3 A#3 B3 C4 ;

Interactive test at the Console

<pre>music ok

72 bpm legato c3 eb3 g3 c4 ok

</pre>

 

=={{header|Go}}==

<br>

As Go doesn't have any audio support in its standard library, we instead build a .wav file which can then be played using a utility such as SoX.

 

import (

}

}

 

=={{header|J}}==

 

 

This assumes a version such as J6 which supports media/wav.

0.25 is the duration of each note (in seconds).

 

 

=={{header|Julia}}==

 

function paudio()

sleep(0.4)

end

 

=={{header|Kotlin}}==

 

When building win32.klib from windows.h, one needs to make sure NOT to filter out utilapiset.h because this is where the Beep function now resides, not in winbase.h as stated in the MSDN documentation.

 

import kotlinx.cinterop.*

val dur = 500

repeat(5) { for (freq in freqs) Beep(freq, dur) }

 

=={{header|Lilypond}}==

The lilypond tool produces musical score sheets and midi files - if asked for - but does not output notes to the sound device directly.

\relative c' {

c d e f

g a b c

 

=={{header|Locomotive Basic}}==

 

20 print "Note","Freq. (Hz)","Period"

30 ' program loop:

110 f=440*(2^((n-10)/12))

120 p=round(62500/f)

140 sound 1,p,100

150 return

 

=={{header|M2000 Interpreter}}==

TUNE use kernel [https://msdn.microsoft.com/en-us/library/windows/desktop/ms679277(v=vs.85).aspx Beep] which is synchronous and not leaving M2000 threads to process, until ends.

 

Module checkit {

\\ using internal speaker

}

checkit

 

 

=={{header|Nanoquery}}==

 

note_freqs = {261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25}

for freq in note_freqs

tg.beep(freq)

 

=={{header|ooRexx}}==

* 24.02.2013 Walter Pachl derived from original REXX version

* Changes: sound(f,sec) --> beep(trunc(f),millisec)

If f.note\==0 Then

Call beep trunc(f.note),dur /* sound the "note". */

 

=={{header|Perl}}==

 

# setup, 1 quarter note is 0.5 seconds (500,000 microseconds)

n 60; n 62; n 64; n 65; n 67; n 69; n 71; n 72;

 

 

=={{header|Phix}}==

 

=={{header|PowerShell}}==

List of frequencies directly taken from the Python example.

foreach($tone in $frequencies){

[Console]::beep($tone, 500)

 

=={{header|Pure Data}}==

=={{header|Python}}==

(Windows)

>>> for note in [261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25]:

winsound.Beep(int(note+.5), 500)

 

=={{header|R}}==

install.packages("audio")

library(audio)

Sys.sleep(.7)

}

 

=={{header|Racket}}==

With a quick and dirty WinMM interface.

#lang racket

(require ffi/unsafe ffi/unsafe/define)

(for ([i '(60 62 64 65 67 69 71 72)]) (midi #x90 i 127) (sleep 0.5))

(sleep 2)

 

=={{header|Raku}}==

(formerly Perl 6)

shell "play -n -c1 synth 0.2 sin %{$_ - 9}"

 

=={{header|REXX}}==

{{works with|Personal REXX}}

{{works with|Regina}}

parse arg ! /*obtain optional arguments from the CL*/

/* [↓] invoke boilerplate REXX code. */

!rex: parse upper version !ver !vernum !verdate .; !brexx= 'BY'==!vernum; !kexx= "KEXX"==!ver; !pcrexx= 'REXX/PERSONAL'==!ver | "REXX/PC"==!ver; !r4= 'REXX-R4'==!ver; !regina= "REXX-REGINA"==left(!ver, 11); !roo= 'REXX-ROO'==!ver; call !env; return

!sys: !cms= !sys=='CMS'; !os2= !sys=="OS2"; !tso= !sys=='TSO' | !sys=="MVS"; !vse= !sys=='VSE'; !dos= pos("DOS", !sys)\==0 | pos('WIN', !sys)\==0 | !sys=="CMD"; !crx= left(!sys, 6)=='DOSCRX'; call !rex; return

 

Programming note: &nbsp;

 

=={{header|Ring}}==

# Project : Musical scale

 

beep(freqs[f][1],300)

next

Output video:

 

[https://www.dropbox.com/s/jf34s6apalw0k7c/CalmoSoftMusicalScale.avi?dl=0 Musical scale]

 

=={{header|Scala}}==

===Windows===

{{libheader|net.java.dev.sna.SNA}}

 

object PlayMusicScale extends App with SNA {

foreach(f => Beep((261.63 * math.pow(2, f / 12.0)).toInt, if (f == 12) 1000 else 500))

println("That's all")

 

=={{header|Sparkling}}==

The following Sparkling program generates a WAVE audio file named "notes.wav"

that can be played in order to achieve the required effect:

var duration = 8.0;

var dataLength = round(sampleRate * duration);

}

 

 

=={{header|Tcl}}==

{{libheader|Snack}}

 

# Encapsulate the tone generation

foreach i {0 2 4 5 7 9 11 12 11 9 7 5 4 2 0} {

play [expr {$tonicFrequency*2**($i/12.0)}] [expr {$i%12?250:500}]

 

=={{header|Ursa}}==

{{trans|Python}}

append 261.63 293.66 329.63 349.23 392.00 440.00 493.88 523.25 notes

 

for (decl int i) (< i (size notes)) (inc i)

ursa.util.sound.beep notes<i> 0.5

 

=={{header|VBA}}==

 

Declare Function Beep Lib "kernel32" (ByVal Freq As Long, ByVal Dur As Long) As Long

Beep Fqs(i), 500

Next

 

=={{header|XPL0}}==

code Sound=39;

real Period; int I;

Note:= Note + (if I&3 then 2 else 1);

];

 

=={{header|ZX Spectrum Basic}}==

20 LET n=0: REM Start at middle C

30 LET d=0.2: REM Make each note 0.2 seconds in duration

80 NEXT l

90 STOP