Musical scale: Difference between revisions

Line 16:

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>DEFINE PTR="CARD"

<syntaxhighlight lang="action!">DEFINE PTR="CARD"

PROC Wait(BYTE frames)

Line 61:

AUDCTL=$00 ;restore default configuration

Wait(20)

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Musical_scale.png Screenshot from Atari 8-bit computer]

Line 74:

=={{header|AmigaBASIC}}==

<~~lang~~ amigabasic>FOR i=1 to 8

<syntaxhighlight lang="amigabasic">FOR i=1 to 8

READ f

SOUND f,10

DATA 261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25</~~lang~~>

DATA 261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25</syntaxhighlight>

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>for key, val in [261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25]

<syntaxhighlight lang="autohotkey">for key, val in [261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25]

SoundBeep, % val, 500</~~lang~~>

SoundBeep, % val, 500</syntaxhighlight>

=={{header|BASIC256}}==

<~~lang~~ ~~BASIC256~~>sound {261.63, 500, 293.66, 500, 329.63, 500, 349.23, 500, 392, 500, 440, 500, 493.88, 500, 523.25, 500}</~~lang~~>

<syntaxhighlight lang="basic256">sound {261.63, 500, 293.66, 500, 329.63, 500, 349.23, 500, 392, 500, 440, 500, 493.88, 500, 523.25, 500}</syntaxhighlight>

=={{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.

<~~lang~~ befunge>> "HGECA@><"8: v

<syntaxhighlight lang="befunge">> "HGECA@><"8: v

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

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

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

>"@1",2*,\,,1-:#^_"/3d",5*,,, @</~~lang~~>

>"@1",2*,\,,1-:#^_"/3d",5*,,, @</syntaxhighlight>

=={{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.

#include<stdio.h>

#include<conio.h>

Line 138:

nosound();

return 0;

}</~~lang~~>

}</syntaxhighlight>

===Windows C===

Line 146:

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>

Line 170:

}

return 0;

}</~~lang~~>

}</syntaxhighlight>

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

Uses Windows MIDI device

<~~lang~~ cpp>

#include <iostream>

#include <windows.h>

Line 248:

return 0;

}

</syntaxhighlight>

</lang>

=={{header|Clojure}}==

<~~lang~~ clojure>(use 'overtone.live)

<syntaxhighlight lang="clojure">(use 'overtone.live)

; Define your desired instrument

Line 265:

(Thread/sleep ms))

(doseq [note (scale :c4 :major)] (play note 500))</~~lang~~>

(doseq [note (scale :c4 :major)] (play note 500))</syntaxhighlight>

=={{header|Commodore BASIC}}==

Line 272:

'''Commodore 64'''

<~~lang~~ commodorebasic>10 rem musical scale

<syntaxhighlight lang="commodorebasic">10 rem musical scale

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</~~lang~~>

500 data 261.63,293.66,329.63,349.23,392,440,493.88,523.25</syntaxhighlight>

'''Commodore 128'''

<~~lang~~ commodorebasic>10 print chr$(147)

<syntaxhighlight lang="commodorebasic">10 print chr$(147)

20 play "o4 cdefgab o5 c"</~~lang~~>

20 play "o4 cdefgab o5 c"</syntaxhighlight>

Line 299:

=={{header|Delphi}}==

program Musical_scale;

Line 315:

Beep(Round(note), 500);

readln;

end.</~~lang~~>

end.</syntaxhighlight>

=={{header|EasyLang}}==

<lang>n[] = [ 262 294 330 349 392 440 494 523 ]

<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

.</~~lang~~>

.</syntaxhighlight>

=={{header|Emacs Lisp}}==

Line 329:

Does not work with the Windows version of Emacs.

<~~lang~~ lisp>(defun play-scale (freq-list dur)

<syntaxhighlight lang="lisp">(defun play-scale (freq-list dur)

"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)</~~lang~~>

(play-scale '(261.63 293.66 329.63 349.23 392.00 440.00 493.88 523.25) .5)</syntaxhighlight>

=={{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.

<lang>HEX

<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>

</lang>

Interactive test at the Console

<pre>music ok

Line 454:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>REM FreeBASIC no tiene la capacidad de emitir sonido de forma nativa.

<syntaxhighlight lang="freebasic">REM FreeBASIC no tiene la capacidad de emitir sonido de forma nativa.

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</~~lang~~>

Sleep</syntaxhighlight>

=={{header|FreePascal}}==

<~~lang~~ pascal>{$mode objfpc}

<syntaxhighlight lang="pascal">{$mode objfpc}

uses windows,math;{ windows only }

var

Line 536:

for i:= 0 to 11 do

beep(Round(440.0*interval**i),500);

end.</~~lang~~>

end.</syntaxhighlight>

=={{header|Go}}==

Line 542:

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.

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 608:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|J}}==

<~~lang~~ J>require'media/wav'

<syntaxhighlight lang="j">require'media/wav'

0.25 wavnote 0 2 4 5 7 9 11 12</~~lang~~>

0.25 wavnote 0 2 4 5 7 9 11 12</syntaxhighlight>

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

Line 623:

=={{header|JavaScript}}==

Using the Web Audio API

<~~lang~~ javascript><!doctype html>

<html>

<head>

Line 660:

</script>

</body>

</html></~~lang~~>

</html></syntaxhighlight>

=={{header|Julia}}==

<~~lang~~ julia>using PortAudio

<syntaxhighlight lang="julia">using PortAudio

function paudio()

Line 688:

sleep(0.4)

end

</syntaxhighlight>

</lang>

=={{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.

<~~lang~~ scala>// Kotlin Native v0.3

<syntaxhighlight lang="scala">// Kotlin Native v0.3

import kotlinx.cinterop.*

Line 703:

val dur = 500

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

}</~~lang~~>

}</syntaxhighlight>

=={{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.

<~~lang~~ lilypond>% Start at middle C

<syntaxhighlight lang="lilypond">% Start at middle C

\relative c' {

c d e f

g a b c

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ locobasic>10 mode 1

<syntaxhighlight lang="locobasic">10 mode 1

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</~~lang~~>

160 data 1,3,5,6,8,10,12,13,-1</syntaxhighlight>

=={{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..

<~~lang~~ lua>c = string.char

<syntaxhighlight lang="lua">c = string.char

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)</~~lang~~>

midi:gsub(".", function(c) io.write(string.format("%02X ", string.byte(c))) end)</syntaxhighlight>

Line 755:

===Lua ASCII===

The task allows for score output, which could also be done natively..

<~~lang~~ lua>staff = {

<syntaxhighlight lang="lua">staff = {

lines = { "", "", "", "", "", "", "", "", "", "", "" },

nnotes = 0,

Line 781:

end

staff:measure()

staff:dump()</~~lang~~>

staff:dump()</syntaxhighlight>

<pre>|----------------|----------------|

Line 797:

===Lua Windows===

Non-portable, O/S-specific, requires <code>alien</code> library..

<~~lang~~ lua>beep = require"alien".kernel32.Beep

<syntaxhighlight lang="lua">beep = require"alien".kernel32.Beep

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</~~lang~~>

end</syntaxhighlight>

=={{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.

<lang>

Module checkit {

\\ using internal speaker

Line 824:

}

checkit

</syntaxhighlight>

</lang>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ mathematica>EmitSound@Sound[SoundNote /@ {0, 2, 4, 5, 7, 9, 11, 12}]</~~lang~~>

<syntaxhighlight lang="mathematica">EmitSound@Sound[SoundNote /@ {0, 2, 4, 5, 7, 9, 11, 12}]</syntaxhighlight>

=={{header|Nanoquery}}==

<~~lang~~ nanoquery>import tonegen

<syntaxhighlight lang="nanoquery">import tonegen

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</~~lang~~>

end</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import endians, math

<syntaxhighlight lang="nim">import endians, math

const

Line 892:

file.write chr(y.byte) # Signed int to byte then to char as it’s easier this way.

file.close()</~~lang~~>

file.close()</syntaxhighlight>

=={{header|ooRexx}}==

<~~lang~~ ~~ooRexx~~>/* REXX ---------------------------------------------------------------

<syntaxhighlight lang="oorexx">/* REXX ---------------------------------------------------------------

* 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</~~lang~~>

Return</syntaxhighlight>

=={{header|Perl}}==

<~~lang~~ perl>use MIDI::Simple;

<syntaxhighlight lang="perl">use MIDI::Simple;

# 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';</~~lang~~>

write_score 'scale.mid';</syntaxhighlight>

=={{header|Phix}}==

Line 945:

You can run this online [http://phix.x10.mx/p2js/Musical_scale.htm here].

--

-- demo\rosetta\Musical_scale.exw

Line 972:

IupClose()

end if

=={{header|PowerShell}}==

List of frequencies directly taken from the Python example.

<~~lang~~ powershell>$frequencies = 261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25

<syntaxhighlight lang="powershell">$frequencies = 261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25

foreach($tone in $frequencies){

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

}</~~lang~~>

}</syntaxhighlight>

=={{header|Processing}}==

Requires the Processing Sound library.

<~~lang~~ java>

//Aamrun, 2nd July 2022

Line 1,003:

delay(500);

}

</syntaxhighlight>

</lang>

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

Line 1,070:

=={{header|Python}}==

(Windows)

<~~lang~~ python>>>> import winsound

<syntaxhighlight lang="python">>>> import winsound

>>> 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)

>>> </~~lang~~>

>>> </syntaxhighlight>

=={{header|R}}==

install.packages("audio")

library(audio)

Line 1,084:

Sys.sleep(.7)

}

</syntaxhighlight>

</lang>

=={{header|Racket}}==

With a quick and dirty WinMM interface.

<~~lang~~ racket>

#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>

</lang>

=={{header|Raku}}==

(formerly Perl 6)

<lang ~~perl6~~>for 0,2,4,5,7,9,11,12 {

<syntaxhighlight lang="raku" line>for 0,2,4,5,7,9,11,12 {

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

}</~~lang~~>

}</syntaxhighlight>

=={{header|REXX}}==

Line 1,112:

<~~lang~~ rexx>/*REXX program sounds eight notes of the C major natural diatonic music scale.*/

<syntaxhighlight lang="rexx">/*REXX program sounds eight notes of the C major natural diatonic music scale.*/

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) )</~~lang~~>

!var: call !fid; if !kexx then return space( dosenv( arg(1) ) ); return space( value( arg(1), , !env) )</syntaxhighlight>

Programming note:  

Line 1,171:

=={{header|Ring}}==

<~~lang~~ ring>

# Project : Musical scale

Line 1,180:

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

</syntaxhighlight>

</lang>

Output video:

Line 1,188:

===Windows===

<~~lang~~ ~~Scala~~>import net.java.dev.sna.SNA

<syntaxhighlight lang="scala">import 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")

}</~~lang~~>

}</syntaxhighlight>

=={{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:

<~~lang~~ ~~Sparkling~~>var sampleRate = 44100.0;

<syntaxhighlight lang="sparkling">var sampleRate = 44100.0;

var duration = 8.0;

var dataLength = round(sampleRate * duration);

Line 1,253:

}

fclose(f);</~~lang~~>

fclose(f);</syntaxhighlight>

=={{header|Tcl}}==

<~~lang~~ tcl>package require sound

<syntaxhighlight lang="tcl">package require sound

# 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}]

}</~~lang~~>

}</syntaxhighlight>

=={{header|Ursa}}==

<~~lang~~ ursa>decl double<> notes

<syntaxhighlight lang="ursa">decl double<> notes

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 0.5

end for</~~lang~~>

end for</syntaxhighlight>

=={{header|VBA}}==

<~~lang~~ vb>Option Explicit

<syntaxhighlight lang="vb">Option Explicit

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

Line 1,301:

Beep Fqs(i), 500

End Sub</~~lang~~>

End Sub</syntaxhighlight>

=={{header|Vlang}}==

Line 1,307:

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.

<~~lang~~ vlang>import strings

<syntaxhighlight lang="vlang">import strings

import os

import encoding.binary

Line 1,367:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|Wren}}==

Line 1,373:

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.

<~~lang~~ ecmascript>import "/sound" for Wav

<syntaxhighlight lang="ecmascript">import "/sound" for Wav

var sampleRate = 44100

Line 1,387:

}

Wav.create("musical_scale.wav", data, sampleRate)</~~lang~~>

Wav.create("musical_scale.wav", data, sampleRate)</syntaxhighlight>

It's also possible to play .wav files which (preferably) have a sample rate of 44.1 kHz using DOME:

<~~lang~~ ecmascript>import "audio" for AudioEngine

<syntaxhighlight lang="ecmascript">import "audio" for AudioEngine

class Main {

Line 1,406:

}

var Game = Main.new()</~~lang~~>

var Game = Main.new()</syntaxhighlight>

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>\Square waves on the beeper speaker:

<syntaxhighlight lang="xpl0">\Square waves on the beeper speaker:

code Sound=39;

real Period; int I;

Line 1,429:

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

];

]</~~lang~~>

]</syntaxhighlight>

=={{header|Yabasic}}==

<~~lang~~ ~~Yabasic~~>// Rosetta Code problem: http://rosettacode.org/wiki/Musical_scale

<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Musical_scale

// by Galileo, 03/2022

Line 1,486:

else // Linux

system("aplay notesyab.wav")

endif</~~lang~~>

endif</syntaxhighlight>

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

<~~lang~~ zxbasic>10 REM Musical scale

<syntaxhighlight lang="zxbasic">10 REM Musical scale

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</~~lang~~>

9000 DATA 2,2,1,2,2,2,1,2:REM WWHWWWH</syntaxhighlight>