Error at least one required implicit or forwarded dependency was not found

1
2
3
4

Error: At least one required implicit or forwarded dependency was not found.
Error: At least one module has an unresolved import due to a missing export function in an implicitly dependent module.
Error: Modules with different CPU types were found.
Warning: At least one delay-load dependency module was not found.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <iostream>
#include <vector>
#include <iomanip>
#include <string>
#include <algorithm>
#include "Stock.h"
using namespace std;



int main() {
	cout <<"                                                Expectancy Calculator" << endl;
	int n, nClone,counter=0;
	cout << "How many expectancies do you want to calculate? " << flush;
	cin >> n;
	nClone = n;
	Stock* stock = new Stock [n];
	vector<double>expectancy;
	while (n--) {

		cout << "Enter ticker> " << flush;
		cin >> stock[counter].ticker;
		for (auto& x : stock[counter].ticker) //captialize ticker
			x = toupper(x);
		cout << "Enter current price> " << flush;
		cin >> stock[counter].currentPrice;
		cout << "Enter target price> " << flush;
		cin >> stock[counter].targetPrice;
		cout << "Enter price stop loss price> " << flush;
		cin >> stock[counter].lossPrice;
		cout << "Enter chance of success> " << flush;
		cin >> stock[counter].successChance;
		stock[counter].lossChance=1-stock[counter].successChance;
		
		stock[counter].expectancy = (((stock[counter].targetPrice- stock[counter].currentPrice)/ stock[counter].currentPrice)) * stock[counter].successChance - ((stock[counter].currentPrice-stock[counter].lossPrice) / stock[counter].currentPrice) * stock[counter].lossChance;
		expectancy.push_back(stock[counter].expectancy);
		counter++;
		if (n != 0) {
			cout << "Onto the next stock" << endl;
		}
		cout << "------------------------------------------------------------------------------------------------------------------------" << endl;

	}
	
	sort(expectancy.begin(), expectancy.end(),greater<float>());
	int j;
	
	printf("%c[4mResultsn%c[0m", 27, 27);

	for (int i = 0; i < nClone; i++) {
		for (int k = 0; k < nClone; k++) {
			if (stock[k].expectancy == expectancy[i]) {
				j = k;
			}
		}
		cout <<i+1 <<". " <<stock[j].ticker << ": " << expectancy[i]*100 <<"%" << endl;
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10

class Stock {
public:
	string ticker;
	double currentPrice;
	double targetPrice;
	double lossPrice;
	double successChance;
	double lossChance;
	double expectancy;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <iostream>
#include <vector>
#include <limits>
#include <iomanip>
#include <string>
#include <algorithm>
#include "Stock.h"
using namespace std;

string returnOrdinal(int number);

int main() {
	cout << "                                                Expectancy Calculator" << endl;
	int n, nClone, counter = 0;
	cout << "How many expectancies do you want to calculate? " << flush;
	cin >> n;
	nClone = n;
	Stock* stock = new Stock[n];
	vector<double>expectancy;
	while (n--) {

		cout << "Enter " << returnOrdinal(counter + 1) << " ticker> " << flush;
		cin >> stock[counter].ticker;
		for (auto& x : stock[counter].ticker) //captialize ticker
			x = toupper(x);
		cout << "Enter current price> " << flush;
		cin >> stock[counter].currentPrice;
		cout << "Enter target price> " << flush;
		cin >> stock[counter].targetPrice;
		cout << "Enter price stop loss price> " << flush;
		cin >> stock[counter].lossPrice;
		cout << "Enter chance of success> " << flush;
		cin >> stock[counter].successChance;
		stock[counter].lossChance = 1 - stock[counter].successChance;

		stock[counter].expectancy = (((stock[counter].targetPrice - stock[counter].currentPrice) / stock[counter].currentPrice)) * stock[counter].successChance - ((stock[counter].currentPrice - stock[counter].lossPrice) / stock[counter].currentPrice) * stock[counter].lossChance;
		expectancy.push_back(stock[counter].expectancy);
		counter++;
		if (n != 0) {
			cout << "Onto the next stock" << endl;
		}
		cout << "------------------------------------------------------------------------------------------------------------------------" << endl;

	}

	sort(expectancy.begin(), expectancy.end(), greater<double>());
	int j;

	cout << "Results" << endl;

	for (int i = 0; i < nClone; i++) {
		for (int k = 0; k < nClone; k++) {
			if (stock[k].expectancy == expectancy[i]) {
				j = k;
			}
		}
		cout << i + 1 << ". " << stock[j].ticker << ": " << expectancy[i] * 100 << "%" << endl;
	}
	int whatever;
	cin >> whatever;
	return 0;
}

string returnOrdinal(int number) {
	switch (number) {
	case 1: return "first";
	case 2: return "second";
	case 3: return "third";
	case 4: return "fourth";
	case 5: return "fifth";
	case 6: return "sixth";
	case 7: return "seventh";
	case 8: return "eighth";
	case 9: return "ninth";
	case 10: return "tenth";
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cctype>
#include <functional>

struct Stock {
	std::string ticker;
	double currentPrice {};
	double targetPrice {};
	double lossPrice {};
	double successChance {};
	double lossChance {};
	double expectancy {};
};

std::string returnOrdinal(size_t number);

int main() {
	std::cout << "                                                Expectancy Calculatorn";

	size_t n {};

	std::cout << "How many expectancies do you want to calculate? ";
	std::cin >> n;

	const auto nClone {n};

	std::vector<Stock> stock(n);
	std::vector<double>expectancy;

	for (size_t counter = 0; counter < n; ++counter) {
		std::cout << "Enter " << returnOrdinal(counter + 1) << " ticker> ";
		std::cin >> stock[counter].ticker;

		for (auto& x : stock[counter].ticker)	//capitalize ticker
			x = static_cast<char>(std::toupper(static_cast<unsigned char>(x)));

		std::cout << "Enter current price> ";
		std::cin >> stock[counter].currentPrice;

		std::cout << "Enter target price> ";
		std::cin >> stock[counter].targetPrice;

		std::cout << "Enter price stop loss price> ";
		std::cin >> stock[counter].lossPrice;

		std::cout << "Enter chance of success> ";
		std::cin >> stock[counter].successChance;

		stock[counter].lossChance = 1 - stock[counter].successChance;
		stock[counter].expectancy = (((stock[counter].targetPrice - stock[counter].currentPrice) / stock[counter].currentPrice)) * stock[counter].successChance - ((stock[counter].currentPrice - stock[counter].lossPrice) / stock[counter].currentPrice) * stock[counter].lossChance;

		expectancy.push_back(stock[counter].expectancy);

		if (counter != n - 1)
			std::cout << "Onto the next stockn";

		std::cout << "------------------------------------------------------------------------------------------------------------------------n";
	}

	std::sort(expectancy.begin(), expectancy.end(), std::greater<double>());

	size_t j {};

	std::cout << "Resultsn";

	for (size_t i = 0; i < nClone; ++i) {
		for (size_t k = 0; k < nClone; ++k)
			if (stock[k].expectancy == expectancy[i])
				j = k;

		std::cout << i + 1 << ". " << stock[j].ticker << ": " << expectancy[i] * 100 << "%n";
	}
}

std::string returnOrdinal(size_t number) {

	const static char* const nums[] {"zero", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth"};

	if (number <= 10)
		return nums[number];

	return ("Unknown");
}