c# – Array of a class or class with multiple property arrays

I have a simple question, why would I use an array of a single class over a class with multiple property arrays?

Context:
I have a series of calculators that extend off a base calculator. Each calculator is intended to calculate the same things but in different ways. Here is the simplified base class (pay attention to the use of Flows):

public abstract class BaseCalculator : ICalculator
    {
        public Flows Flows { get; private set; }

        protected double() BaseCurve { get; private set; }
        protected double CurrentBalance { get; private set; }
        protected int CurrentPeriod { get; private set; }

        public BaseCalculator(int periodLength, double() baseCurve, double currentBalance)
        {
            Cashflows = new Flows(periodLength);
            BaseCurve = baseCurve;
            CurrentBalance = currentBalance;
        }

        //no default implementation will suffice
        protected abstract void CalcOne();
        protected abstract void CalcTwo();

        //many calcs do not implement
        protected virtual void CalcThree() {  }

        public ICalculator SetPeriod(int period)
        {
            CurrentPeriod = period;
            return this;
        }

        public virtual void Calculate()
        {
            //order matters
            CalcOne();
            CalcTwo();
            CalcThree();
            CalcFour();
        }

        protected virtual void CalcFour() => Flows.FlowFour(CurrentPeriod) = CurrentBalance + Flows.FlowTwo(CurrendPeriod) * BaseCurve(CurrentPeriod);

There is a list of 10 values each calculator must compute, these 10 values are calculated for n periods. Right now I have a class that contains a property array for each one of these values. NOTE: these properties can rely on one another in the calculator as seen above. Here is a trimmed down example class:

  public class Flows
    {
        public Flows(int periodLength)
        {
            FlowOne = new double(periodLength);
            FlowTwo = new double(periodLength);
            FlowThree = new double(periodLength);
            FlowFour = new double(periodLength);
        }

        public double() FlowOne { get; private set; }
        public double() FlowTwo{ get; private set; }
        public double() FlowThree { get; private set; }
        public double() FlowFour { get; private set; }
    }

So is there any reason why the above class would be less favorable than an array of the below class in my use case? I chose the above option because I assign values to these “Flows” at different times plus they do rely on one another.

public class Flow
    {
        public Flow() {}

        public double FlowOne { get; set; }
        public double FlowTwo{ get; set; }
        public double FlowThree { get; set; }
        public double FlowFour { get; set; }
    }

use in base calculator: public Flow() Flows { get; private set; }