Musical scale: Difference between revisions
m
syntax highlighting fixup automation
(Added Processing implementation) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 16:
=={{header|Action!}}==
<
PROC Wait(BYTE frames)
Line 61:
AUDCTL=$00 ;restore default configuration
Wait(20)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Musical_scale.png Screenshot from Atari 8-bit computer]
Line 74:
=={{header|AmigaBASIC}}==
<
READ f
SOUND f,10
NEXT
DATA 261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25</
=={{header|AutoHotkey}}==
{{works with|AutoHotkey 1.1}}
<
SoundBeep, % val, 500</
=={{header|BASIC256}}==
<
=={{header|Befunge}}==
Line 94:
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<
>"@1",2*,\,,1-:#^_"/3d",5*,,, @</
=={{header|C}}==
Line 111:
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.
<syntaxhighlight lang="c">
#include<stdio.h>
#include<conio.h>
Line 138:
nosound();
return 0;
}</
===Windows C===
Line 146:
Beep() can only play integer frequencies and thus the tones are noticeably lower than the ones played by sound() above.
<syntaxhighlight lang="c">
#include<windows.h>
#include<stdio.h>
Line 170:
}
return 0;
}</
=={{header|C++}}==
Uses Windows MIDI device
<
#include <iostream>
#include <windows.h>
Line 248:
return 0;
}
</syntaxhighlight>
=={{header|Clojure}}==
{{libheader|Overtone}}
<
; Define your desired instrument
Line 265:
(Thread/sleep ms))
(doseq [note (scale :c4 :major)] (play note 500))</
=={{header|Commodore BASIC}}==
Line 272:
'''Commodore 64'''
<
15 rem rosetta code
20 print chr$(147)
Line 289:
90 for d=1 to 25:next
95 next i
500 data 261.63,293.66,329.63,349.23,392,440,493.88,523.25</
'''Commodore 128'''
<
20 play "o4 cdefgab o5 c"</
Line 299:
=={{header|Delphi}}==
{{libheader| Winapi.Windows}}
<syntaxhighlight lang="delphi">
program Musical_scale;
Line 315:
Beep(Round(note), 500);
readln;
end.</
=={{header|EasyLang}}==
<syntaxhighlight lang="text">n[] = [ 262 294 330 349 392 440 494 523 ]
for i range len n[]
sound [ n[i] 0.5 ]
sleep 0.6
.</
=={{header|Emacs Lisp}}==
Line 329:
Does not work with the Windows version of Emacs.
<
"Play a list of frequencies."
(setq header (unibyte-string ; AU header:
Line 350:
(play-sound `(sound :data ,s)))
(play-scale '(261.63 293.66 329.63 349.23 392.00 440.00 493.88 523.25) .5)</
=={{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.
<syntaxhighlight lang="text">HEX
\ PC speaker hardware control (requires giveio or DOSBOX for windows operation)
042 constant fctrl 061 constant sctrl
Line 444:
: 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 ;
</syntaxhighlight>
Interactive test at the Console
<pre>music ok
Line 454:
=={{header|FreeBASIC}}==
<
REM La función Sound no es mía, incluyo los créditos correspondientes.
' Sound Function v0.3 For DOS/Linux/Win by yetifoot
Line 526:
Sound(494, 250) 'B4
Sound(523, 250) 'C5
Sleep</
=={{header|FreePascal}}==
<
uses windows,math;{ windows only }
var
Line 536:
for i:= 0 to 11 do
beep(Round(440.0*interval**i),500);
end.</
=={{header|Go}}==
Line 542:
<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 (
Line 608:
}
}
}</
=={{header|J}}==
<
0.25 wavnote 0 2 4 5 7 9 11 12</
This assumes a version such as J6 which supports media/wav.
Line 623:
=={{header|JavaScript}}==
Using the Web Audio API
<
<html>
<head>
Line 660:
</script>
</body>
</html></
=={{header|Julia}}==
<
function paudio()
Line 688:
sleep(0.4)
end
</syntaxhighlight>
=={{header|Kotlin}}==
Line 694:
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.*
Line 703:
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:
Line 730:
140 sound 1,p,100
150 return
160 data 1,3,5,6,8,10,12,13,-1</
=={{header|Lua}}==
Line 736:
===Lua Portable===
The most portable native solution that could actually ''play'' the scale (''with some external help from a media player'') would be to write a MIDI file..
<
midi = "MThd" .. c(0,0,0,6,0,0,0,1,0,96) -- header
midi = midi .. "MTrk" .. c(0,0,0,8*8+4) -- track
Line 749:
-- (optional: hex dump to screen)
midi:gsub(".", function(c) io.write(string.format("%02X ", string.byte(c))) end)</
{{out}}
<pre>4D 54 68 64 00 00 00 06 00 00 00 01 00 60 4D 54 72 6B 00 00 00 44 00 90 3C 40 60 80 3C 00 00 90 3E 40 60 80 3E 00 00 90 40 40 60 80 40 00 00 90 41 40 60 80 41 00 00 90 43 40 60 80 43 00 00 90 45 40 60 80 45 00 00 90 47 40 60 80 47 00 00 90 48 40 60 80 48 00 00 FF 2F 00</pre>
Line 755:
===Lua ASCII===
The task allows for score output, which could also be done natively..
<
lines = { "", "", "", "", "", "", "", "", "", "", "" },
nnotes = 0,
Line 781:
end
staff:measure()
staff:dump()</
{{out}}
<pre>|----------------|----------------|
Line 797:
===Lua Windows===
Non-portable, O/S-specific, requires <code>alien</code> library..
<
beep:types{ret='long', abi='stdcall', 'long', 'long'}
for _,step in ipairs{0,2,4,5,7,9,11,12} do
beep(math.floor(261.63 * 2^(step/12) + 0.5), 1000)
end</
=={{header|M2000 Interpreter}}==
Line 809:
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.
<syntaxhighlight lang="text">
Module checkit {
\\ using internal speaker
Line 824:
}
checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{header|Nanoquery}}==
<
note_freqs = {261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25}
Line 837:
for freq in note_freqs
tg.beep(freq)
end</
=={{header|Nim}}==
{{trans|Go}}
<
const
Line 892:
file.write chr(y.byte) # Signed int to byte then to char as it’s easier this way.
file.close()</
=={{header|ooRexx}}==
<
* 24.02.2013 Walter Pachl derived from original REXX version
* Changes: sound(f,sec) --> beep(trunc(f),millisec)
Line 928:
If f.note\==0 Then
Call beep trunc(f.note),dur /* sound the "note". */
Return</
=={{header|Perl}}==
<
# setup, 1 quarter note is 0.5 seconds (500,000 microseconds)
Line 939:
n 60; n 62; n 64; n 65; n 67; n 69; n 71; n 72;
write_score 'scale.mid';</
=={{header|Phix}}==
Line 945:
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/Musical_scale.htm here].
<!--<
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\Musical_scale.exw
Line 972:
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</
=={{header|PowerShell}}==
List of frequencies directly taken from the Python example.
<
foreach($tone in $frequencies){
[Console]::beep($tone, 500)
}</
=={{header|Processing}}==
Requires the Processing Sound library.
<
//Aamrun, 2nd July 2022
Line 1,003:
delay(500);
}
</syntaxhighlight>
=={{header|Pure Data}}==
Line 1,070:
=={{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}}==
<syntaxhighlight lang="r">
install.packages("audio")
library(audio)
Line 1,084:
Sys.sleep(.7)
}
</syntaxhighlight>
=={{header|Racket}}==
With a quick and dirty WinMM interface.
<
#lang racket
(require ffi/unsafe ffi/unsafe/define)
Line 1,100:
(for ([i '(60 62 64 65 67 69 71 72)]) (midi #x90 i 127) (sleep 0.5))
(sleep 2)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
shell "play -n -c1 synth 0.2 sin %{$_ - 9}"
}</
=={{header|REXX}}==
Line 1,112:
{{works with|Personal REXX}}
{{works with|Regina}}
<
parse arg ! /*obtain optional arguments from the CL*/
/* [↓] invoke boilerplate REXX code. */
Line 1,149:
!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
!var: call !fid; if !kexx then return space( dosenv( arg(1) ) ); return space( value( arg(1), , !env) )</
Programming note:
Line 1,171:
=={{header|Ring}}==
<
# Project : Musical scale
Line 1,180:
beep(freqs[f][1],300)
next
</syntaxhighlight>
Output video:
Line 1,188:
===Windows===
{{libheader|net.java.dev.sna.SNA}}
<
object PlayMusicScale extends App with SNA {
Line 1,199:
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);
Line 1,253:
}
fclose(f);</
=={{header|Tcl}}==
{{libheader|Snack}}
<
# Encapsulate the tone generation
Line 1,279:
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
end for</
=={{header|VBA}}==
<
Declare Function Beep Lib "kernel32" (ByVal Freq As Long, ByVal Dur As Long) As Long
Line 1,301:
Beep Fqs(i), 500
Next
End Sub</
=={{header|Vlang}}==
Line 1,307:
<br>
As Vlang 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 os
import encoding.binary
Line 1,367:
}
}
}</
=={{header|Wren}}==
Line 1,373:
{{libheader|Wren-sound}}
As Wren-cli doesn't have any built-in audio support, we instead build a .wav file which can then be played using a utility such as rhythmbox or SoX.
<
var sampleRate = 44100
Line 1,387:
}
}
Wav.create("musical_scale.wav", data, sampleRate)</
<br>
It's also possible to play .wav files which (preferably) have a sample rate of 44.1 kHz using DOME:
{{libheader|DOME}}
<
class Main {
Line 1,406:
}
var Game = Main.new()</
=={{header|XPL0}}==
<
code Sound=39;
real Period; int I;
Line 1,429:
Note:= Note + (if I&3 then 2 else 1);
];
]</
=={{header|Yabasic}}==
{{trans|Phix}}
<
// by Galileo, 03/2022
Line 1,486:
else // Linux
system("aplay notesyab.wav")
endif</
=={{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
Line 1,498:
80 NEXT l
90 STOP
9000 DATA 2,2,1,2,2,2,1,2:REM WWHWWWH</
| |||