ExtendedStrings\Strings\Note

Complexity

Total Complexity

24

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	fromCents()	0	16	3
B	fromName()	0	29	6
A	fromFrequency()	0	4	1
A	getCents()	0	7	1
A	getFrequency()	0	4	1
A	__toString()	0	9	2
A	getName()	0	4	1
A	getAccidental()	0	4	1
A	getOctave()	0	4	1
A	getDifference()	0	4	1
A	normalizeAccidental()	0	12	4

<?php

declare(strict_types = 1);

namespace ExtendedStrings\Strings;

class Note
{
    const ACCIDENTAL_NATURAL = '';
    const ACCIDENTAL_SHARP = '♯';
    const ACCIDENTAL_FLAT = '♭';
    const ACCIDENTAL_DOUBLE_SHARP = 'x';
    const ACCIDENTAL_DOUBLE_FLAT = '♭♭';
    const ACCIDENTAL_QUARTER_SHARP = '¼♯';
    const ACCIDENTAL_QUARTER_FLAT = '¼♭';
    const ACCIDENTAL_THREE_QUARTER_SHARP = '¾♯';
    const ACCIDENTAL_THREE_QUARTER_FLAT = '¾♭';

    const PATTERN_ACCIDENTAL_SHARP = '([♯s#]|sharp)';
    const PATTERN_ACCIDENTAL_FLAT = '([♭fb]|flat)';
    const PATTERN_ACCIDENTAL_QUARTER = '(quarter|¼|1\/4)[ -]?';
    const PATTERN_ACCIDENTAL_3_QUARTER = '((three|3)[ -]quarter|¾|3\/4)[ -]?';

    private static $accidentalPatterns = [
        '' => self::ACCIDENTAL_NATURAL,
        self::PATTERN_ACCIDENTAL_FLAT => self::ACCIDENTAL_FLAT,
        self::PATTERN_ACCIDENTAL_SHARP => self::ACCIDENTAL_SHARP,
        '(\-|' . self::PATTERN_ACCIDENTAL_QUARTER . self::PATTERN_ACCIDENTAL_FLAT . ')' => self::ACCIDENTAL_QUARTER_FLAT,
        '(\+|' . self::PATTERN_ACCIDENTAL_QUARTER . self::PATTERN_ACCIDENTAL_SHARP . ')' => self::ACCIDENTAL_QUARTER_SHARP,
        '(𝄫|bb|double[ -]' . self::PATTERN_ACCIDENTAL_FLAT . ')' => self::ACCIDENTAL_DOUBLE_FLAT,
        '(𝄪|♯♯|##|double[ -]' . self::PATTERN_ACCIDENTAL_SHARP . ')' => self::ACCIDENTAL_DOUBLE_SHARP,
        '(' . self::PATTERN_ACCIDENTAL_FLAT . '\-|' . self::PATTERN_ACCIDENTAL_3_QUARTER . self::PATTERN_ACCIDENTAL_FLAT . ')' => self::ACCIDENTAL_THREE_QUARTER_FLAT,
        '(' . self::PATTERN_ACCIDENTAL_SHARP . '\+|' . self::PATTERN_ACCIDENTAL_3_QUARTER . self::PATTERN_ACCIDENTAL_SHARP . ')' => self::ACCIDENTAL_THREE_QUARTER_SHARP,
    ];

    private static $accidentalCents = [
        self::ACCIDENTAL_NATURAL => 0,
        self::ACCIDENTAL_FLAT => -100,
        self::ACCIDENTAL_SHARP => 100,
        self::ACCIDENTAL_QUARTER_FLAT => -50,
        self::ACCIDENTAL_QUARTER_SHARP => 50,
        self::ACCIDENTAL_DOUBLE_FLAT => -200,
        self::ACCIDENTAL_DOUBLE_SHARP => 200,
        self::ACCIDENTAL_THREE_QUARTER_FLAT => -150,
        self::ACCIDENTAL_THREE_QUARTER_SHARP => 150,
    ];

    private static $preferredAccidentals = [
        self::ACCIDENTAL_NATURAL,
        self::ACCIDENTAL_SHARP,
        self::ACCIDENTAL_FLAT,
        self::ACCIDENTAL_QUARTER_SHARP,
        self::ACCIDENTAL_QUARTER_FLAT,
        self::ACCIDENTAL_DOUBLE_SHARP,
        self::ACCIDENTAL_DOUBLE_FLAT,
        self::ACCIDENTAL_THREE_QUARTER_FLAT,
        self::ACCIDENTAL_THREE_QUARTER_SHARP,
    ];

    private static $names = [
        'C' => 0,
        'D' => 200,
        'E' => 400,
        'F' => 500,
        'G' => 700,
        'A' => 900,
        'B' => 1100,
    ];

    private $name;
    private $accidental;
    private $octave;
    private $difference;

    /**
     * Internal constructor. Use one of the factory methods to create a Note.
     *
     * @see Note::fromCents()
     * @see Note::fromFrequency()
     * @see Note::fromName()
     *
     * @param string $name         The note name (A-G).
     * @param string $accidental   The accidental (one of the Note::ACCIDENTAL_
     *                             constants).
     * @param int    $octave       The octave, in scientific pitch notation.
     * @param float  $difference   The note's difference in cents from 12-TET.
     */
    private function __construct(string $name, string $accidental, int $octave, float $difference)
    {
        if ($octave > 1000) {
            throw new \InvalidArgumentException(sprintf('Invalid octave: %d', $octave));
        }

        $this->name = $name;
        $this->accidental = $accidental;
        $this->octave = $octave;
        $this->difference = $difference;
    }

    /**
     * Instantiate a Note from a number of cents.
     *
     * @param float    $cents                A number of cents above C4.
     * @param string[] $preferredAccidentals A list of accidentals in order of
     *                                       preference. This will be merged
     *                                       with a default list.
     *
     * @return self
     */
    public static function fromCents(float $cents, array $preferredAccidentals = []): self
    {
        $rounded = (int) round($cents / 50) * 50;
        $difference = $cents - $rounded;
        $octave = (int) floor($rounded / 1200) + 4;
        $centsWithoutOctave = $rounded - (($octave - 4) * 1200);
        $preferredAccidentals = array_merge($preferredAccidentals, self::$preferredAccidentals);
        foreach ($preferredAccidentals as $accidental) {
            $accidentalCents = self::$accidentalCents[$accidental];
            if (($name = array_search($centsWithoutOctave - $accidentalCents, self::$names, true)) !== false) {
                return new self((string) $name, $accidental, $octave, $difference);
            }
        }

        throw new \InvalidArgumentException(sprintf('Failed to find note name for cents: %d', $cents)); // @codeCoverageIgnore
    }

    /**
     * Instantiate a Note from a note name.
     *
     * @param string $name A note name with an accidental and an octave in
     *                     scientific pitch notation, e.g. C#4 or Eb5.
     *
     * @return \ExtendedStrings\Strings\Note
     */
    public static function fromName(string $name): self
    {
        $original = $name;
        if (!preg_match('/^[a-g]/i', $name, $matches)) {
            throw new \InvalidArgumentException(sprintf('Invalid note name: %s', $original));
        }
        $noteName = strtoupper($matches[0]);
        $name = substr($name, strlen($matches[0]));
        if (preg_match('/^\-[0-9]+$/i', $name)) {
            throw new \InvalidArgumentException(sprintf(
                'Ambiguous note: %s (does "-" mean a quarter-flat or a negative?)',
                $original
            ));
        }
        $octave = 4;
        $difference = 0;
        if (preg_match('/\/?(\-?[0-9]+)?( ([\+-][0-9]+)[c¢])?$/iu', $name, $matches)) {
            if (isset($matches[1])) {
                $octave = intval($matches[1]);
            }
            if (isset($matches[3])) {
                $difference = intval($matches[3]);
            }
            $name = substr($name, 0, strlen($name) - strlen($matches[0]));
        }
        $accidental = self::normalizeAccidental($name);

        return new self($noteName, $accidental, $octave, $difference);
    }

    /**
     * Instantiate a Note from a frequency.
     *
     * @param float $frequency            The frequency (in Hz).
     * @param float $A4                   The frequency of A4, for reference.
     * @param array $preferredAccidentals Some preferred accidentals.
     *
     * @return self
     */
    public static function fromFrequency($frequency, float $A4 = 440.0, array $preferredAccidentals = []): self
    {
        return self::fromCents(Cent::frequencyToCents($frequency, $A4), $preferredAccidentals);
    }

    /**
     * Returns the note as a number of cents above C4.
     *
     * @return float
     */
    public function getCents(): float
    {
        return self::$names[$this->name]
            + self::$accidentalCents[$this->accidental]
            + (($this->octave - 4) * 1200)
            + $this->difference;
    }

    /**
     * Returns the note as a frequency.
     *
     * @param float $A4 The frequency of A4 (in Hz), for reference.
     *
     * @return float
     */
    public function getFrequency(float $A4 = 440.0): float
    {
        return Cent::centsToFrequency($this->getCents() - 900, $A4);
    }

    /**
     * Returns a string representation of the note.
     *
     * @return string
     */
    public function __toString(): string
    {
        $output = sprintf('%s%s%d', $this->name, $this->accidental, $this->octave);
        if ((int) round($this->difference) !== 0) {
            $output .= sprintf(' %+d¢', round($this->difference));
        }

        return $output;
    }

    /**
     * Returns the simple note name (one of A-G).
     *
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Returns the accidental (one of the Note::ACCIDENTAL_ constants).
     *
     * @return string
     */
    public function getAccidental(): string
    {
        return $this->accidental;
    }

    /**
     * Returns the octave (in scientific pitch notation).
     *
     * @return int
     */
    public function getOctave(): int
    {
        return $this->octave;
    }

    /**
     * Returns the difference between the note and its 12-TET form, in cents.
     *
     * @return float
     */
    public function getDifference(): float
    {
        return $this->difference;
    }

    /**
     * @param string $accidental
     *
     * @return string
     */
    private static function normalizeAccidental(string $accidental): string
    {
        $accidental = trim($accidental);

        foreach (self::$accidentalPatterns as $pattern => $replacement) {
            if ($accidental === $replacement || preg_match('/^' . $pattern . '$/iu', $accidental)) {
                return $replacement;
            }
        }

        throw new \InvalidArgumentException(sprintf('Invalid accidental: %s', $accidental));
    }
}