public void GetCorrectScaleDegree(int pitch, ScaleDegree expectedScaleDegree)
        {
            var scaleDegreeEvaluator = new ScaleDegreeEvaluator();
            var scaleDegree          = scaleDegreeEvaluator.GetScaleDegreeFromNote(pitch);

            Assert.AreEqual(expectedScaleDegree, scaleDegree);
        }
        public void Setup()
        {
            _factory = FuxExMachinaTestFactoryProvider.GetTestFactory();
            var scaleDegreeEvaluator = new ScaleDegreeEvaluator();

            _ruleEvaluator = new DissonantLeapRuleEvaluator(scaleDegreeEvaluator, new CompositionContext());
        }
 /// <inheritdoc />
 /// <summary>
 /// AppogiaturaDecorator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 /// <param name="random">The CryptoRandom to use</param>
 public AppogiaturaDecorator(
     ScaleDegreeEvaluator scaleDegreeEvaluator,
     CryptoRandom random
     ) : base(
         scaleDegreeEvaluator,
         random
         )
 {
 }
Ejemplo n.º 4
0
 /// <inheritdoc />
 /// <summary>
 /// MordentDecorator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 /// <param name="random">The CryptoRandom to use</param>
 public MordentDecorator(
     ScaleDegreeEvaluator scaleDegreeEvaluator,
     CryptoRandom random
     ) : base(
         scaleDegreeEvaluator,
         random
         )
 {
 }
Ejemplo n.º 5
0
 /// <inheritdoc />
 /// <summary>
 /// PassingToneDecorator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 /// <param name="random">The CryptoRandom to use</param>
 public PassingToneDecorator(
     ScaleDegreeEvaluator scaleDegreeEvaluator,
     CryptoRandom random
     ) : base(
         scaleDegreeEvaluator,
         random
         )
 {
 }
Ejemplo n.º 6
0
 /// <summary>
 /// NotePair constructor.
 /// </summary>
 /// <param name="cantusFirmusNote">The cantus firmus note</param>
 /// <param name="counterPointNote">The counterpoint note</param>
 /// <param name="arrivedFromCompositionContext">The CompositionContext from which this NotePair was generated</param>
 /// <param name="arrivedFromNoteChoice">The NoteChoice which led to this NotePair being generated</param>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use with this NotePair</param>
 public NotePair(
     int cantusFirmusNote,
     int counterPointNote,
     CompositionContext arrivedFromCompositionContext,
     NoteChoice arrivedFromNoteChoice,
     ScaleDegreeEvaluator scaleDegreeEvaluator
     )
 {
     CantusFirmusNote = cantusFirmusNote;
     CounterPointNote = counterPointNote;
     ArrivedFromCompositionContext = arrivedFromCompositionContext;
     ArrivedFromNoteChoice         = arrivedFromNoteChoice;
     _scaleDegreeEvaluator         = scaleDegreeEvaluator;
 }
Ejemplo n.º 7
0
        /// <inheritdoc />
        /// <summary>
        /// Decorates the composition based on the current and next notes.
        /// </summary>
        /// <param name="currentNote">The current note</param>
        /// <param name="nextNote">The next note</param>
        /// <returns>A list of decorative notes, possibly empty</returns>
        protected override List <int> GetPossibleDecorations(int currentNote, int nextNote)
        {
            var currentScaleDegree = ScaleDegreeEvaluator.GetScaleDegreeFromNote(currentNote);
            var nextScaleDegree    = ScaleDegreeEvaluator.GetScaleDegreeFromNote(nextNote);

            if (!currentScaleDegree.IsThirdWith(nextScaleDegree) || Random.Next(1, 3) % 2 != 0)
            {
                return(EmptyDecoration);
            }

            return(new List <int> {
                (currentNote + nextNote) / 2
            });
        }
        public static FuxExMachinaFactory GetTestFactory()
        {
            if (_instance != null)
            {
                return(_instance);
            }

            var random = new CryptoRandom();
            var scaleDegreeEvaluator      = new ScaleDegreeEvaluator();
            var compositionContext        = new CompositionContext();
            var compositionContexts       = new CompositionContextCollection();
            var noteChoices               = new NoteChoiceCollection();
            var noteChoiceWeightGenerator = new NoteChoiceWeightGenerator(random);

            var ruleEvaluatorFactory = new RuleEvaluatorFactory(
                new AscendingSeventhRuleEvaluator(scaleDegreeEvaluator),
                new DissonanceRuleEvaluator(),
                new DissonantLeapRuleEvaluator(scaleDegreeEvaluator, compositionContext),
                new DoubledLeapRuleEvaluator(),
                new DoubledNoteRuleEvaluator(scaleDegreeEvaluator),
                new LeapReturnRuleEvaluator(),
                new MultipleLeapRuleEvaluator(),
                new ParallelPerfectsRuleEvaluator(scaleDegreeEvaluator)
                );

            var aggregateEvaluator = new AggregateRuleEvaluator(ruleEvaluatorFactory);

            var mordentDecorator     = new MordentDecorator(scaleDegreeEvaluator, random);
            var passingToneDecorator = new PassingToneDecorator(scaleDegreeEvaluator, random);
            var appogiaturaDecorator = new AppogiaturaDecorator(scaleDegreeEvaluator, random);

            _instance = new FuxExMachinaFactory(
                compositionContexts,
                noteChoices,
                noteChoiceWeightGenerator,
                scaleDegreeEvaluator,
                new CompositionEvaluator(aggregateEvaluator),
                new CompositionDecorator(passingToneDecorator, mordentDecorator, appogiaturaDecorator),
                new CryptoRandom(),
                new FuxExMachinaNullLogger()
                );

            return(_instance);
        }
Ejemplo n.º 9
0
 /// <summary>
 /// FuxExMachinaFactory constructor.
 /// </summary>
 /// <param name="compositionContexts">The composition contexts to use</param>
 /// <param name="noteChoices">The note choices to use</param>
 /// <param name="noteChoiceWeightGenerator">The note choice weight generator to use</param>
 /// <param name="scaleDegreeEvaluator">The scale degree evaluator to use</param>
 /// <param name="compositionEvaluator">The composition evaluator to use</param>
 /// <param name="compositionDecorator">The composition decorator to use</param>
 /// <param name="random">The random number generator to use</param>
 /// <param name="logger">The logger to use</param>
 public FuxExMachinaFactory(
     CompositionContextCollection compositionContexts,
     NoteChoiceCollection noteChoices,
     NoteChoiceWeightGenerator noteChoiceWeightGenerator,
     ScaleDegreeEvaluator scaleDegreeEvaluator,
     CompositionEvaluator compositionEvaluator,
     CompositionDecorator compositionDecorator,
     CryptoRandom random,
     IFuxExMachinaLogger logger
     )
 {
     CompositionContexts       = compositionContexts;
     NoteChoices               = noteChoices;
     NoteChoiceWeightGenerator = noteChoiceWeightGenerator;
     ScaleDegreeEvaluator      = scaleDegreeEvaluator;
     CompositionEvaluator      = compositionEvaluator;
     CompositionDecorator      = compositionDecorator;
     Random = random;
     Logger = logger;
 }
Ejemplo n.º 10
0
        /// <inheritdoc />
        /// <summary>
        /// Decorates the composition based on the current and next notes.
        /// </summary>
        /// <param name="currentNote">The current note</param>
        /// <param name="nextNote">The next note</param>
        /// <returns>A list of decorative notes, possibly empty</returns>
        protected override List <int> GetPossibleDecorations(int currentNote, int nextNote)
        {
            var currentScaleDegree = ScaleDegreeEvaluator.GetScaleDegreeFromNote(currentNote);
            var nextScaleDegree    = ScaleDegreeEvaluator.GetScaleDegreeFromNote(nextNote);

            if (!currentScaleDegree.IsAdjacentTo(nextScaleDegree) || Random.Next(1, 3) % 2 != 0)
            {
                return(EmptyDecoration);
            }

            if (currentNote < nextNote)
            {
                return(new List <int> {
                    currentNote + 1, currentNote - 1, currentNote
                });
            }

            return(currentScaleDegree != ScaleDegree.Sixth
                ? new List <int> {
                currentNote - 1, currentNote + 1, currentNote
            }
                : EmptyDecoration);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// CompositionContext constructor.
        /// </summary>
        /// <param name="previousNotes">The previous notes in the composition</param>
        /// <param name="currentNotes">The current notes in the composition</param>
        /// <param name="scaleDegreeEvaluator">ScaleDegreeEvaluator used to help initialize class properties</param>
        public CompositionContext(NotePair previousNotes, NotePair currentNotes,
                                  ScaleDegreeEvaluator scaleDegreeEvaluator)
        {
            CantusFirmusNoteScaleDegree = scaleDegreeEvaluator.GetScaleDegreeFromNote(currentNotes.CantusFirmusNote);
            CantusFirmusNoteMotion      = GetNoteMotionFromNotes(
                previousNotes.CantusFirmusNote,
                currentNotes.CantusFirmusNote
                );
            CantusFirmusNoteMotionSpan = GetNoteMotionSpanFromNotes(
                previousNotes.CantusFirmusNote,
                currentNotes.CantusFirmusNote
                );

            CounterPointNoteScaleDegree = scaleDegreeEvaluator.GetScaleDegreeFromNote(currentNotes.CounterPointNote);
            CounterPointNoteMotion      = GetNoteMotionFromNotes(
                previousNotes.CounterPointNote,
                currentNotes.CounterPointNote
                );
            CounterPointNoteMotionSpan = GetNoteMotionSpanFromNotes(
                previousNotes.CounterPointNote,
                currentNotes.CounterPointNote
                );
        }
 /// <summary>
 /// DoubledNoteRuleEvaluator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 public DoubledNoteRuleEvaluator(ScaleDegreeEvaluator scaleDegreeEvaluator)
 {
     _scaleDegreeEvaluator = scaleDegreeEvaluator;
 }
 /// <summary>
 /// ParallelPerfectsRuleEvaluator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 public ParallelPerfectsRuleEvaluator(ScaleDegreeEvaluator scaleDegreeEvaluator)
 {
     _scaleDegreeEvaluator = scaleDegreeEvaluator;
 }
 /// <summary>
 /// BaseCompositionDecorator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 /// <param name="random">The CryptoRandom to use</param>
 protected BaseCompositionDecorator(ScaleDegreeEvaluator scaleDegreeEvaluator, CryptoRandom random)
 {
     ScaleDegreeEvaluator = scaleDegreeEvaluator;
     Random = random;
 }
 /// <summary>
 /// DissonantLeapRuleEvaluator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 /// <param name="context">The CompositionContext to use</param>
 public DissonantLeapRuleEvaluator(ScaleDegreeEvaluator scaleDegreeEvaluator, CompositionContext context)
 {
     _scaleDegreeEvaluator = scaleDegreeEvaluator;
     _context = context;
 }
 /// <summary>
 /// AscendingSeventhRuleEvaluator constructor.
 /// </summary>
 /// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
 public AscendingSeventhRuleEvaluator(ScaleDegreeEvaluator scaleDegreeEvaluator)
 {
     _scaleDegreeEvaluator = scaleDegreeEvaluator;
 }