Solve the coding errors for upvotemake test-statsg++ -g -std=c++.pdf

Solve the coding errors for upvote
make test-stats
g++ -g -std=c++14 -Wall -Werror=return-type -Werror=uninitialized -Wno-sign-compare -o test-
stats stats.o week-data.o test/catch/catch.o test/test-stats.o
Undefined symbols for architecture x86_64:
"stDev(WeekData*, int)", referenced from:
C_A_T_C_H_T_E_S_T_2() in test-stats.o
"getMean(WeekData*, int)", referenced from:
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [test-stats] Error 1
make test-state
g++ -g -std=c++14 -Wall -Werror=return-type -Werror=uninitialized -Wno-sign-compare -c -o
state.o state.cpp
state.cpp:65:12: error: no member named 'stDev' in 'State'; did you mean simply 'stDev'?
return State::stDev(weeks, numberOfDataPoints);
^~~~~~~~~~~~
stDev
./stats.hpp:5:19: note: 'stDev' declared here
static double stDev(WeekData* weeks, int count);
^
1 error generated.
make: *** [state.o] Error 1
make test-morbidity
g++ -g -std=c++14 -Wall -Werror=return-type -Werror=uninitialized -Wno-sign-compare -c -o
state.o state.cpp
state.cpp:65:12: error: no member named 'stDev' in 'State'; did you mean simply 'stDev'?
^~~~~~~~~~~~
stDev
./stats.hpp:5:19: note: 'stDev' declared here

^
1 error generated.
make: *** [state.o] Error 1
Code
test-morbidity.cpp
#include "catch/catch.hpp"
#include "../morbidity.hpp"
const std::string INVALID_STATE = "foo";
TEST_CASE("Testing Morbidity class")
{
Morbidity dataset;
CHECK(!dataset.load("foo.bar"));
CHECK(dataset.load("data.csv"));
CHECK(Approx(-1.0) == dataset.getMean(INVALID_STATE));
CHECK(Approx(1036.78).epsilon(0.01) == dataset.getMean("Alabama"));
CHECK(Approx(81.17).epsilon(0.01) == dataset.getMean("Alaska"));
CHECK(16 == dataset.getStateOutlierCount("Alabama"));
auto outliers = dataset.getStateOutliers("Alabama");
CHECK("2020-07-25 - total deaths: 1333" == outliers.at(0));
CHECK_THAT(dataset.getOutlierInfoForAllStates(), Catch::Contains("West Virginia: 19"));
}
test-state.cpp
#include

#include "../state.hpp"
TEST_CASE("Testing State class on calculation") {
State bama("Alabama");
CHECK("Alabama" == bama.getName());
bama.addWeek("2020-05-02,2000");
bama.addWeek("2020-05-09,2000");
bama.addWeek("2020-05-16,100");
bama.addWeek("2020-05-23,2000");
bama.addWeek("2020-05-30,2000");
bama.addWeek("2020-06-06,2000");
CHECK(Approx(1683.33).epsilon(0.01) == bama.getMeanDeaths());
CHECK(Approx(708.08).epsilon(0.01) == bama.getStDev());
CHECK(1 == bama.getOutlierCount());
auto outliers = bama.getOutlierInfos();
}
TEST_CASE("Testing State class on rule of three") {
State bama("Alabama");
CHECK("Alabama" == bama.getName());
State bama1(bama);
CHECK("Alabama" == bama1.getName());
State bama2;
bama2 = bama;

CHECK("Alabama" == bama2.getName());
}
test-stats.cpp
#include "../stats.hpp"
#include "../week-data.hpp"
WeekData data[] = {
WeekData("1776-07-04,1"), // Just some static test data.
WeekData("1776-07-11,2"), // The dates are not important
WeekData("1776-07-18,3"), // since we are just trying to test the
WeekData("1776-07-25,5"), // statistical calculations
WeekData("1776-08-02,6")
};
TEST_CASE("Testing Mean")
{
// Comparing doubles, can use Approx() to allow some epsilon difference
CHECK(Approx(3.4) == getMean(data, 5));
}
TEST_CASE("Testing Stdev")
{
CHECK(Approx(1.85).epsilon(0.01) == stDev(data, 5));
}
TEST_CASE("Testing empty list")
{
// let's call the getMean of no numbers: 0
CHECK(Approx(0) == getMean({}, 0));
CHECK(Approx(0) == stDev({}, 0));

}
// Compile & run:
// make clean test
morbidity.cpp
#include "morbidity.hpp"
#include "state.hpp"
#include
#include
Morbidity::Morbidity() : numberOfStates(0), states(nullptr) {
}
Morbidity::~Morbidity() {
for (int i = 0; i < numberOfStates; i++) {
delete states[i];
}
delete[] states;
}
bool Morbidity::load(const std::string& filename) {
std::ifstream file(filename);
if (!file.is_open()) {
return false;
}

std::string line;
std::string stateName;
while (std::getline(file, line)) {
std::istringstream iss(line);
std::string state, weekData;
std::getline(iss, state, ',');
std::getline(iss, weekData);
if (state != stateName) {
stateName = state;
State* newState = new State(stateName);
if (numberOfStates < 65) {
if (states == nullptr) {
states = new State*[65];
}
states[numberOfStates] = newState;
numberOfStates++;
}
}
try {
int deaths = std::stoi(weekData);
if (states != nullptr) {
states[numberOfStates - 1]->addWeek(weekData);
}
} catch (const std::invalid_argument& e) {

}
}
file.close();
return true;
}
double Morbidity::getMean(const std::string& stateName) const {
if (states[i]->getName() == stateName) {
return states[i]->getMeanDeaths();
}
}
return -1.0;
}
int Morbidity::getStateOutlierCount(const std::string& stateName) const {
return states[i]->getOutlierCount();
}
}
return 0;
}
std::vector Morbidity::getStateOutliers(const std::string& stateName) const {
return states[i]->getOutlierInfos();

}
}
return std::vector();
}
std::string Morbidity::getOutlierInfoForAllStates() const {
std::string outlierInfo;
outlierInfo += states[i]->getName() + ": " + std::to_string(states[i]->getOutlierCount()) + "
outlying weeksn";
}
return outlierInfo;
}
morbidity.hpp
#ifndef MORBIDITY_HPP
#define MORBIDITY_HPP
#include
#include
class State;
class Morbidity {
public:
Morbidity();
~Morbidity();

bool load(const std::string& filename);
double getMean(const std::string& stateName) const;
int getStateOutlierCount(const std::string& stateName) const;
std::vector getStateOutliers(const std::string& stateName) const;
std::string getOutlierInfoForAllStates() const;
private:
int numberOfStates;
State** states;
};
#endif
state.cpp
#include "state.hpp"
#include "week-data.hpp"
#include "stats.hpp"
State::State() : name(""), weeks(nullptr), numberOfDataPoints(0) {
// Default constructor
}
State::State(std::string name) : name(name), numberOfDataPoints(0) {
// Constructor with a name
weeks = new WeekData[500]; // Assuming a maximum of 500 data points
}
State::State(const State& rhs) : name(rhs.name), numberOfDataPoints(rhs.numberOfDataPoints)
{
// Copy constructor
weeks = new WeekData[500];

for (int i = 0; i < numberOfDataPoints; i++) {
weeks[i] = rhs.weeks[i];
}
}
State& State::operator=(const State& rhs) {
// Assignment operator
if (this == &rhs) {
return *this;
}
name = rhs.name;
numberOfDataPoints = rhs.numberOfDataPoints;
if (weeks) {
delete[] weeks;
}
weeks = new WeekData[500];
weeks[i] = rhs.weeks[i];
}
return *this;
}
State::~State() {
// Destructor
delete[] weeks;
}

std::string State::getName() const {
return name;
}
void State::addWeek(std::string weekData) {
// Implement function to add week data
if (numberOfDataPoints < 500) {
weeks[numberOfDataPoints] = WeekData(weekData);
numberOfDataPoints++;
}
}
double State::getMeanDeaths() const {
return /*State::*/getMean(weeks, numberOfDataPoints);
}
double State::getStDev() const {
}
int State::getOutlierCount() const {
int outlierCount = 0;
double mean = getMeanDeaths();
double stDeviation = getStDev();
if (std::abs(weeks[i].getDeathCount() - mean) > 2 * stDeviation) {
outlierCount++;
}

}
return outlierCount;
}
std::vector State::getOutlierInfos() const {
std::vector outlierInfos;
double mean = getMeanDeaths();
double stDeviation = getStDev();
if (std::abs(weeks[i].getDeathCount() - mean) > 2 * stDeviation) {
outlierInfos.push_back(weeks[i].info());
}
}
return outlierInfos;
}
state.hpp
#ifndef STATE_HPP
#define STATE_HPP
#include
#include
class WeekData;
class State {
public:

State();
State(std::string name);
State(const State& rhs);
State& operator=(const State& rhs);
~State();
std::string getName() const;
void addWeek(std::string weekData);
double getMeanDeaths() const;
double getStDev() const;
int getOutlierCount() const;
std::vector getOutlierInfos() const;
private:
std::string name;
WeekData* weeks;
int numberOfDataPoints;
};
#endif
stats.cpp
#include "stats.hpp"
#include
double /*Stats::*/getMean(WeekData* weeks, int count) {
double sum = 0.0;
for (int i = 0; i < count; i++) {
sum += weeks[i].getDeathCount();
}
return sum / count;
}

double /*Stats::*/stDev(WeekData* weeks, int count) {
double mean = getMean(weeks, count);
double sumSquaredDiffs = 0.0;
for (int i = 0; i < count; i++) {
double diff = weeks[i].getDeathCount() - mean;
sumSquaredDiffs += diff * diff;
}
double variance = sumSquaredDiffs / count;
return std::sqrt(variance);
}
stats.hpp
#ifndef STATS_HPP
#define STATS_HPP
static double getMean(WeekData* weeks, int count);
#endif

Solve the coding errors for upvotemake test-statsg++ -g -std=c++.pdf

Recommended

Recommended

More Related Content

Similar to Solve the coding errors for upvotemake test-statsg++ -g -std=c++.pdf

Similar to Solve the coding errors for upvotemake test-statsg++ -g -std=c++.pdf (20)

More from snewfashion

More from snewfashion (9)

Recently uploaded

Recently uploaded (20)

Solve the coding errors for upvotemake test-statsg++ -g -std=c++.pdf