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?

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

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