Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/java/Component.java | // Component interface
public abstract class Component {
public abstract void operation();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
// Create leaf components
Leaf leaf1 = new Leaf("1");
Leaf leaf2 = new Leaf("2");
// Create composite components and add leaf components to them
Composite composite1 = new Composite("A");
composite1.add(leaf1);
composite1.add(leaf2);
Leaf leaf3 = new Leaf("3");
Leaf leaf4 = new Leaf("4");
Composite composite2 = new Composite("B");
composite2.add(leaf3);
composite2.add(leaf4);
// Create another composite and add the first two composites to it
Composite composite = new Composite("Root");
composite.add(composite1);
composite.add(composite2);
// Operation on the whole composite structure
composite.operation();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/java/Leaf.java | // Leaf class
public class Leaf extends Component {
private String name;
public Leaf(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("Leaf " + name + " operation");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/cpp/Component.h | // Component interface
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/cpp/Composite.h | #include <iostream>
#include <vector>
#include "Component.h"
// Composite class
class Composite : public Component {
private:
std::string name;
std::vector<Component*> children;
public:
Composite(const std::string& name) : name(name) {}
void add(Component* component) {
children.push_back(component);
}
void remove(Component* component) {
// Not implementing remove for simplicity
}
void operation() override {
std::cout << "Composite " << name << " operation:" << std::endl;
for (Component* child : children) {
child->operation();
}
}
~Composite() {
for (Component* child : children) {
delete child;
}
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/cpp/Leaf.h | #include <iostream>
#include "Component.h"
// Leaf class
class Leaf : public Component {
private:
std::string name;
public:
Leaf(const std::string& name) : name(name) {}
void operation() override {
std::cout << "Leaf " << name << " operation" << std::endl;
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/cpp/main.cpp | #include "Leaf.h"
#include "Composite.h"
int main() {
// Create leaf components
Leaf* leaf1 = new Leaf("1");
Leaf* leaf2 = new Leaf("2");
// Create composite components and add leaf components to them
Composite* composite1 = new Composite("A");
composite1->add(leaf1);
composite1->add(leaf2);
Leaf* leaf3 = new Leaf("3");
Leaf* leaf4 = new Leaf("4");
Composite* composite2 = new Composite("B");
composite2->add(leaf3);
composite2->add(leaf4);
// Create another composite and add the first two composites to it
Composite* composite = new Composite("Root");
composite->add(composite1);
composite->add(composite2);
// Operation on the whole composite structure
composite->operation();
// Clean up memory
delete composite;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/python/composite_pattern.py | from abc import ABC, abstractmethod
from typing import List
# Component interface
class Component(ABC):
@abstractmethod
def operation(self) -> None:
pass
# Leaf class
class Leaf(Component):
def __init__(self, name: str) -> None:
self.name = name
def operation(self) -> None:
print(f"Leaf {self.name} operation")
# Composite class
class Composite(Component):
def __init__(self, name: str) -> None:
self.name = name
self.children: List[Component] = []
def add(self, component: Component) -> None:
self.children.append(component)
def remove(self, component: Component) -> None:
self.children.remove(component)
def operation(self) -> None:
print(f"Composite {self.name} operation:")
for child in self.children:
child.operation()
# Client code
if __name__ == "__main__":
# Create leaf components
leaf1 = Leaf("1")
leaf2 = Leaf("2")
# Create composite components and add leaf components to them
composite1 = Composite("A")
composite1.add(leaf1)
composite1.add(leaf2)
leaf3 = Leaf("3")
leaf4 = Leaf("4")
composite2 = Composite("B")
composite2.add(leaf3)
composite2.add(leaf4)
# Create another composite and add the first two composites to it
composite = Composite("Root")
composite.add(composite1)
composite.add(composite2)
# Operation on the whole composite structure
composite.operation()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern/java/Main.java | // Product interface
interface Pizza {
void prepare();
void bake();
void cut();
void box();
}
// Concrete products
class CheesePizza implements Pizza {
public void prepare() {
System.out.println("Preparing Cheese Pizza...");
}
public void bake() {
System.out.println("Baking Cheese Pizza...");
}
public void cut() {
System.out.println("Cutting Cheese Pizza...");
}
public void box() {
System.out.println("Boxing Cheese Pizza...");
}
}
class PepperoniPizza implements Pizza {
public void prepare() {
System.out.println("Preparing Pepperoni Pizza...");
}
public void bake() {
System.out.println("Baking Pepperoni Pizza...");
}
public void cut() {
System.out.println("Cutting Pepperoni Pizza...");
}
public void box() {
System.out.println("Boxing Pepperoni Pizza...");
}
}
// Creator interface
interface PizzaStore {
Pizza createPizza();
default void orderPizza() {
Pizza pizza = createPizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
// Concrete creators
class NYStylePizzaStore implements PizzaStore {
public Pizza createPizza() {
return new CheesePizza();
}
}
class ChicagoStylePizzaStore implements PizzaStore {
public Pizza createPizza() {
return new PepperoniPizza();
}
}
// Client code
public class Main {
public static void main(String[] args) {
PizzaStore nyStore = new NYStylePizzaStore();
nyStore.orderPizza();
PizzaStore chicagoStore = new ChicagoStylePizzaStore();
chicagoStore.orderPizza();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern/cpp/main.cpp | #include <iostream>
// Product interface
class Pizza {
public:
virtual void prepare() = 0;
virtual void bake() = 0;
virtual void cut() = 0;
virtual void box() = 0;
};
// Concrete products
class CheesePizza : public Pizza {
public:
void prepare() override {
std::cout << "Preparing Cheese Pizza..." << std::endl;
}
void bake() override {
std::cout << "Baking Cheese Pizza..." << std::endl;
}
void cut() override {
std::cout << "Cutting Cheese Pizza..." << std::endl;
}
void box() override {
std::cout << "Boxing Cheese Pizza..." << std::endl;
}
};
class PepperoniPizza : public Pizza {
public:
void prepare() override {
std::cout << "Preparing Pepperoni Pizza..." << std::endl;
}
void bake() override {
std::cout << "Baking Pepperoni Pizza..." << std::endl;
}
void cut() override {
std::cout << "Cutting Pepperoni Pizza..." << std::endl;
}
void box() override {
std::cout << "Boxing Pepperoni Pizza..." << std::endl;
}
};
// Creator interface
class PizzaStore {
public:
virtual Pizza* createPizza() = 0;
void orderPizza() {
Pizza* pizza = createPizza();
pizza->prepare();
pizza->bake();
pizza->cut();
pizza->box();
delete pizza;
}
};
// Concrete creators
class NYStylePizzaStore : public PizzaStore {
public:
Pizza* createPizza() override {
return new CheesePizza();
}
};
class ChicagoStylePizzaStore : public PizzaStore {
public:
Pizza* createPizza() override {
return new PepperoniPizza();
}
};
// Client code
int main() {
PizzaStore* nyStore = new NYStylePizzaStore();
nyStore->orderPizza();
delete nyStore;
PizzaStore* chicagoStore = new ChicagoStylePizzaStore();
chicagoStore->orderPizza();
delete chicagoStore;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/factory-method-pattern/python/factory_method_pattern.py | from abc import ABC, abstractmethod
# Product interface
class Pizza(ABC):
@abstractmethod
def prepare(self) -> None:
pass
@abstractmethod
def bake(self) -> None:
pass
@abstractmethod
def cut(self) -> None:
pass
@abstractmethod
def box(self) -> None:
pass
# Concrete products
class CheesePizza(Pizza):
def prepare(self) -> None:
print("Preparing Cheese Pizza...")
def bake(self) -> None:
print("Baking Cheese Pizza...")
def cut(self) -> None:
print("Cutting Cheese Pizza...")
def box(self) -> None:
print("Boxing Cheese Pizza...")
class PepperoniPizza(Pizza):
def prepare(self) -> None:
print("Preparing Pepperoni Pizza...")
def bake(self) -> None:
print("Baking Pepperoni Pizza...")
def cut(self) -> None:
print("Cutting Pepperoni Pizza...")
def box(self) -> None:
print("Boxing Pepperoni Pizza...")
# Creator interface
class PizzaStore(ABC):
@abstractmethod
def create_pizza(self) -> Pizza:
pass
def order_pizza(self) -> None:
pizza = self.create_pizza()
pizza.prepare()
pizza.bake()
pizza.cut()
pizza.box()
# Concrete creators
class NYStylePizzaStore(PizzaStore):
def create_pizza(self) -> Pizza:
return CheesePizza()
class ChicagoStylePizzaStore(PizzaStore):
def create_pizza(self) -> Pizza:
return PepperoniPizza()
# Client code
if __name__ == "__main__":
ny_store = NYStylePizzaStore()
ny_store.order_pizza()
chicago_store = ChicagoStylePizzaStore()
chicago_store.order_pizza()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern/java/Main.java | package design-patterns.oberserver-pattern.java;
public class main {
}
import java.util.ArrayList;
import java.util.List;
// Observer interface
interface Observer {
void update(String message);
}
// Subject interface
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notify(String message);
}
// Concrete Observer
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
// Concrete Subject
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void notify(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
public void doSomething() {
// Perform some actions
System.out.println("Subject is doing something...");
// Notify observers
notify("Something has happened!");
}
}
// Client code
public class Main {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.doSomething();
subject.detach(observer2);
subject.doSomething();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern/cpp/main.cpp | #include <iostream>
#include <vector>
#include <string>
// Observer interface
class Observer {
public:
virtual void update(const std::string& message) = 0;
};
// Subject interface
class Subject {
public:
virtual void attach(Observer* observer) = 0;
virtual void detach(Observer* observer) = 0;
virtual void notify(const std::string& message) = 0;
};
// Concrete Observer
class ConcreteObserver : public Observer {
private:
std::string name;
public:
ConcreteObserver(const std::string& name) : name(name) {}
void update(const std::string& message) override {
std::cout << name << " received message: " << message << std::endl;
}
};
// Concrete Subject
class ConcreteSubject : public Subject {
private:
std::vector<Observer*> observers;
public:
void attach(Observer* observer) override {
observers.push_back(observer);
}
void detach(Observer* observer) override {
auto it = std::find(observers.begin(), observers.end(), observer);
if (it != observers.end()) {
observers.erase(it);
}
}
void notify(const std::string& message) override {
for (auto observer : observers) {
observer->update(message);
}
}
void doSomething() {
// Perform some actions
std::cout << "Subject is doing something..." << std::endl;
// Notify observers
notify("Something has happened!");
}
};
// Client code
int main() {
ConcreteSubject subject;
Observer* observer1 = new ConcreteObserver("Observer 1");
Observer* observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.doSomething();
subject.detach(observer2);
subject.doSomething();
// Cleanup
delete observer1;
delete observer2;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/oberserver-pattern/python/oberserver_pattern.py | from typing import List
class Observer:
def update(self, message: str) -> None:
pass
class Subject:
_observers: List[Observer] = []
def attach(self, observer: Observer) -> None:
self._observers.append(observer)
def detach(self, observer: Observer) -> None:
self._observers.remove(observer)
def notify(self, message: str) -> None:
for observer in self._observers:
observer.update(message)
class ConcreteObserver(Observer):
def __init__(self, name: str):
self.name = name
def update(self, message: str) -> None:
print(f"{self.name} received message: {message}")
class ConcreteSubject(Subject):
def do_something(self) -> None:
# Perform some actions
print("Subject is doing something...")
# Notify observers
self.notify("Something has happened!")
# Client code
if __name__ == "__main__":
subject = ConcreteSubject()
observer1 = ConcreteObserver("Observer 1")
observer2 = ConcreteObserver("Observer 2")
subject.attach(observer1)
subject.attach(observer2)
subject.do_something()
subject.detach(observer2)
subject.do_something()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern/java/Main.java | // Subject interface
interface Subject {
void request();
}
// RealSubject class
class RealSubject implements Subject {
public void request() {
System.out.println("RealSubject: Handling request.");
}
}
// Proxy class
class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
if (checkAccess()) {
realSubject.request();
logAccess();
}
}
private boolean checkAccess() {
System.out.println("Proxy: Checking access permissions.");
return true;
}
private void logAccess() {
System.out.println("Proxy: Logging the time of request.");
}
}
// Client code
public class Main {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
Proxy proxy = new Proxy(realSubject);
proxy.request();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern/cpp/main.cpp | #include <iostream>
// Subject interface
class Subject {
public:
virtual void request() = 0;
};
// RealSubject class
class RealSubject : public Subject {
public:
void request() override {
std::cout << "RealSubject: Handling request." << std::endl;
}
};
// Proxy class
class Proxy : public Subject {
private:
RealSubject* realSubject;
bool checkAccess() {
std::cout << "Proxy: Checking access permissions." << std::endl;
return true;
}
void logAccess() {
std::cout << "Proxy: Logging the time of request." << std::endl;
}
public:
Proxy(RealSubject* realSubject) : realSubject(realSubject) {}
void request() override {
if (checkAccess()) {
realSubject->request();
logAccess();
}
}
};
// Client code
int main() {
RealSubject realSubject;
Proxy proxy(&realSubject);
proxy.request();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/proxy-pattern/python/proxy_pattern.py | from abc import ABC, abstractmethod
class Subject(ABC):
@abstractmethod
def request(self) -> None:
pass
class RealSubject(Subject):
def request(self) -> None:
print("RealSubject: Handling request.")
class Proxy(Subject):
def __init__(self, real_subject: RealSubject) -> None:
self._real_subject = real_subject
def request(self) -> None:
if self.check_access():
self._real_subject.request()
self.log_access()
def check_access(self) -> bool:
print("Proxy: Checking access permissions.")
return True
def log_access(self) -> None:
print("Proxy: Logging the time of request.")
# Client code
if __name__ == "__main__":
real_subject = RealSubject()
proxy = Proxy(real_subject)
proxy.request()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern/java/Main.java | import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
abstract class SortingAlgorithm {
abstract List<Integer> sort(List<Integer> data);
List<Integer> templateMethod(List<Integer> data) {
preprocess(data);
List<Integer> sortedData = sort(data);
postprocess(sortedData);
return sortedData;
}
private void preprocess(List<Integer> data) {
System.out.println("Preprocessing data...");
}
private void postprocess(List<Integer> sortedData) {
System.out.println("Postprocessing sorted data...");
}
}
class BubbleSort extends SortingAlgorithm {
@Override
List<Integer> sort(List<Integer> data) {
System.out.println("Bubble sorting...");
Collections.sort(data);
return data;
}
}
class QuickSort extends SortingAlgorithm {
@Override
List<Integer> sort(List<Integer> data) {
System.out.println("Quick sorting...");
Collections.sort(data);
return data;
}
}
public class Main {
public static void main(String[] args) {
List<Integer> data = new ArrayList<>(List.of(5, 2, 7, 1, 9));
BubbleSort bubbleSort = new BubbleSort();
List<Integer> sortedData = bubbleSort.templateMethod(data);
System.out.print("Sorted data using Bubble Sort:");
for (int num : sortedData) {
System.out.print(" " + num);
}
System.out.println();
QuickSort quickSort = new QuickSort();
sortedData = quickSort.templateMethod(data);
System.out.print("Sorted data using Quick Sort:");
for (int num : sortedData) {
System.out.print(" " + num);
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern/cpp/main.cpp | #include <iostream>
#include <vector>
#include <algorithm>
class SortingAlgorithm {
public:
virtual std::vector<int> sort(std::vector<int>& data) = 0;
std::vector<int> templateMethod(std::vector<int>& data) {
preprocess(data);
std::vector<int> sortedData = sort(data);
postprocess(sortedData);
return sortedData;
}
virtual ~SortingAlgorithm() {}
private:
void preprocess(std::vector<int>& data) {
std::cout << "Preprocessing data..." << std::endl;
}
void postprocess(std::vector<int>& sortedData) {
std::cout << "Postprocessing sorted data..." << std::endl;
}
};
class BubbleSort : public SortingAlgorithm {
public:
std::vector<int> sort(std::vector<int>& data) override {
std::cout << "Bubble sorting..." << std::endl;
std::sort(data.begin(), data.end());
return data;
}
};
class QuickSort : public SortingAlgorithm {
public:
std::vector<int> sort(std::vector<int>& data) override {
std::cout << "Quick sorting..." << std::endl;
std::sort(data.begin(), data.end());
return data;
}
};
int main() {
std::vector<int> data = {5, 2, 7, 1, 9};
BubbleSort bubbleSort;
std::vector<int> sortedData = bubbleSort.templateMethod(data);
std::cout << "Sorted data using Bubble Sort:";
for (int num : sortedData) {
std::cout << " " << num;
}
std::cout << std::endl;
QuickSort quickSort;
sortedData = quickSort.templateMethod(data);
std::cout << "Sorted data using Quick Sort:";
for (int num : sortedData) {
std::cout << " " << num;
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/template-method-pattern/python/template_method_pattern.py | from abc import ABC, abstractmethod
from typing import List
class SortingAlgorithm(ABC):
@abstractmethod
def sort(self, data: List[int]) -> List[int]:
pass
def template_method(self, data: List[int]) -> List[int]:
self._preprocess(data)
sorted_data = self.sort(data)
self._postprocess(sorted_data)
return sorted_data
def _preprocess(self, data: List[int]) -> None:
print("Preprocessing data...")
def _postprocess(self, sorted_data: List[int]) -> None:
print("Postprocessing sorted data...")
class BubbleSort(SortingAlgorithm):
def sort(self, data: List[int]) -> List[int]:
print("Bubble sorting...")
return sorted(data)
class QuickSort(SortingAlgorithm):
def sort(self, data: List[int]) -> List[int]:
print("Quick sorting...")
return sorted(data)
# Client code
if __name__ == "__main__":
data = [5, 2, 7, 1, 9]
bubble_sort = BubbleSort()
sorted_data = bubble_sort.template_method(data)
print("Sorted data using Bubble Sort:", sorted_data)
quick_sort = QuickSort()
sorted_data = quick_sort.template_method(data)
print("Sorted data using Quick Sort:", sorted_data)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern/java/Forest.java | import java.util.HashMap;
import java.util.Map;
// Flyweight interface
interface TreeType {
void render(int x, int y);
}
// Concrete flyweight
class TreeTypeImpl implements TreeType {
private String name;
private String color;
private String texture;
public TreeTypeImpl(String name, String color, String texture) {
this.name = name;
this.color = color;
this.texture = texture;
}
public void render(int x, int y) {
System.out.println("Render " + name + " tree at (" + x + ", " + y + ") with color " + color + " and texture " + texture);
}
}
// Flyweight factory
class TreeFactory {
private static Map<String, TreeType> treeTypes = new HashMap<>();
public static TreeType getTreeType(String name, String color, String texture) {
String key = name + "_" + color + "_" + texture;
if (!treeTypes.containsKey(key)) {
treeTypes.put(key, new TreeTypeImpl(name, color, texture));
}
return treeTypes.get(key);
}
}
// Context
class Tree {
private int x;
private int y;
private TreeType treeType;
public Tree(int x, int y, TreeType treeType) {
this.x = x;
this.y = y;
this.treeType = treeType;
}
public void render() {
treeType.render(x, y);
}
}
// Client code
public class Forest {
public static void main(String[] args) {
Forest forest = new Forest();
forest.plantTree(1, 2, "Pine", "Green", "Thick");
forest.plantTree(3, 4, "Oak", "Brown", "Thin");
forest.plantTree(5, 6, "Pine", "Green", "Thick");
forest.draw();
}
private final java.util.List<Tree> trees = new java.util.ArrayList<>();
public void plantTree(int x, int y, String name, String color, String texture) {
TreeType treeType = TreeFactory.getTreeType(name, color, texture);
Tree tree = new Tree(x, y, treeType);
trees.add(tree);
}
public void draw() {
for (Tree tree : trees) {
tree.render();
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern/cpp/main.cpp | #include <iostream>
#include <string>
#include <unordered_map>
// Flyweight interface
class TreeType {
public:
virtual void render(int x, int y) = 0;
};
// Concrete flyweight
class TreeTypeImpl : public TreeType {
private:
std::string name;
std::string color;
std::string texture;
public:
TreeTypeImpl(const std::string& name, const std::string& color, const std::string& texture)
: name(name), color(color), texture(texture) {}
void render(int x, int y) override {
std::cout << "Render " << name << " tree at (" << x << ", " << y << ") with color " << color << " and texture " << texture << std::endl;
}
};
// Flyweight factory
class TreeFactory {
private:
std::unordered_map<std::string, TreeType*> treeTypes;
public:
~TreeFactory() {
for (auto& entry : treeTypes) {
delete entry.second; // Clean up allocated TreeType objects
}
}
TreeType* getTreeType(const std::string& name, const std::string& color, const std::string& texture) {
std::string key = name + "_" + color + "_" + texture;
if (treeTypes.find(key) == treeTypes.end()) {
treeTypes[key] = new TreeTypeImpl(name, color, texture);
}
return treeTypes[key];
}
};
// Context
class Tree {
private:
int x;
int y;
TreeType* treeType;
public:
Tree(int x, int y, TreeType* treeType) : x(x), y(y), treeType(treeType) {}
void render() {
treeType->render(x, y);
}
};
// Client code
int main() {
TreeFactory treeFactory;
Tree* trees[3];
trees[0] = new Tree(1, 2, treeFactory.getTreeType("Pine", "Green", "Thick"));
trees[1] = new Tree(3, 4, treeFactory.getTreeType("Oak", "Brown", "Thin"));
trees[2] = new Tree(5, 6, treeFactory.getTreeType("Pine", "Green", "Thick"));
for (int i = 0; i < 3; ++i) {
trees[i]->render();
delete trees[i];
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/flyweight-pattern/python/flyweight_pattern.py | from typing import Dict
class TreeType:
def __init__(self, name: str, color: str, texture: str):
self.name = name
self.color = color
self.texture = texture
def render(self, x: int, y: int) -> None:
print(f"Render {self.name} tree at ({x}, {y}) with color {self.color} and texture {self.texture}")
class TreeFactory:
_tree_types: Dict[str, TreeType] = {}
@staticmethod
def get_tree_type(name: str, color: str, texture: str) -> TreeType:
key = f"{name}_{color}_{texture}"
if key not in TreeFactory._tree_types:
TreeFactory._tree_types[key] = TreeType(name, color, texture)
return TreeFactory._tree_types[key]
class Tree:
def __init__(self, x: int, y: int, tree_type: TreeType):
self.x = x
self.y = y
self.tree_type = tree_type
def render(self) -> None:
self.tree_type.render(self.x, self.y)
class Forest:
def __init__(self):
self.trees = []
def plant_tree(self, x: int, y: int, name: str, color: str, texture: str) -> None:
tree_type = TreeFactory.get_tree_type(name, color, texture)
tree = Tree(x, y, tree_type)
self.trees.append(tree)
def draw(self) -> None:
for tree in self.trees:
tree.render()
# Client code
if __name__ == "__main__":
forest = Forest()
forest.plant_tree(1, 2, "Pine", "Green", "Thick")
forest.plant_tree(3, 4, "Oak", "Brown", "Thin")
forest.plant_tree(5, 6, "Pine", "Green", "Thick")
forest.draw()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/java/Singleton.java | public class Singleton {
// Private static instance variable
private static Singleton instance;
// Private constructor to prevent instantiation from outside
private Singleton() {}
// Static method to get the instance
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
// Method to perform some action
public void performAction() {
System.out.println("Singleton instance performing an action.");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
// Get the singleton instance
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
// Verify that both instances are the same
System.out.println("Singleton instance addresses: " + singleton1 + " and " + singleton2);
// Perform some action using the singleton instance
singleton1.performAction();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/cpp/Singleton.cpp | #include "Singleton.h"
// Initialize static member variable
Singleton* Singleton::_instance = nullptr;
// Definition of getInstance() method
Singleton* Singleton::getInstance() {
if (_instance == nullptr) {
_instance = new Singleton();
}
return _instance;
}
// Definition of destructor
Singleton::~Singleton() {
delete _instance;
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/cpp/Singleton.h | #ifndef SINGLETON_H
#define SINGLETON_H
class Singleton {
private:
static Singleton* _instance;
// Private constructor to prevent instantiation
Singleton() {}
public:
// Public static method to get the instance
static Singleton* getInstance();
// Optional: Define destructor to release resources
~Singleton();
// Disable copy constructor and assignment operator
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
#endif // SINGLETON_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/cpp/main.cpp | #include <iostream>
#include <thread> // For std::this_thread
#include <chrono> // For std::chrono
#include <atomic> // For std::atomic
#include <mutex> // For std::mutex and std::lock_guard
#include "src/creational/Singleton.h"
std::atomic<bool> exitFlag(false);
std::mutex exitMutex;
// Function to check for ESC key press
void checkForExit() {
while (!exitFlag) {
if (std::cin.peek() == 27) { // Check for ASCII code of ESC key
std::lock_guard<std::mutex> lock(exitMutex);
exitFlag = true;
}
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Check every 100 milliseconds
}
}
int main() {
std::cout << "Press ESC to exit the program." << std::endl;
/**
* <Singleton example>
*/
// Create instances
Singleton* singleton1 = Singleton::getInstance();
Singleton* singleton2 = Singleton::getInstance();
std::cout << "Singleton instance created." << std::endl;
std::cout << "Singleton instance addresses: " << singleton1 << " and " << singleton2 << std::endl;
std::cout << "Press any key to delete singleton instances..." << std::endl;
std::cin.get(); // Wait for any key press
// Cleanup (optional)
delete singleton1;
delete singleton2;
std::cout << "Singleton instances deleted." << std::endl;
/**
* </Singleton example>
*/
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/cpp | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/singleton-pattern/cpp/tests/TestSingleton.cpp | #include "gtest/gtest.h"
#include "../Singleton.h"
// Test case for Singleton class
TEST(SingletonTest, InstanceTest) {
// Get the instance of Singleton
Singleton* singleton1 = Singleton::getInstance();
Singleton* singleton2 = Singleton::getInstance();
// Check if both pointers point to the same instance
EXPECT_EQ(singleton1, singleton2);
// Cleanup (optional)
delete singleton1;
}
// Test case for destruction of Singleton instance
TEST(SingletonTest, DestructionTest) {
// Get the instance of Singleton
Singleton* singleton = Singleton::getInstance();
// Delete the instance
delete singleton;
// Get the instance again
Singleton* newSingleton = Singleton::getInstance();
// Check if the new instance is different from the deleted one
EXPECT_NE(singleton, newSingleton);
}
// Main function to run tests
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern/java/Main.java | import java.util.HashMap;
import java.util.Map;
// Prototype interface
interface Prototype {
Prototype clone();
}
// Concrete prototype 1
class ConcretePrototype1 implements Prototype {
private int attr1;
private String attr2;
public ConcretePrototype1(int attr1, String attr2) {
this.attr1 = attr1;
this.attr2 = attr2;
}
public Prototype clone() {
return new ConcretePrototype1(attr1, attr2);
}
public void print() {
System.out.println("ConcretePrototype1: { attr1: " + attr1 + ", attr2: " + attr2 + " }");
}
}
// Concrete prototype 2
class ConcretePrototype2 implements Prototype {
private float attr3;
private int[] attr4;
public ConcretePrototype2(float attr3, int[] attr4) {
this.attr3 = attr3;
this.attr4 = attr4.clone();
}
public Prototype clone() {
return new ConcretePrototype2(attr3, attr4);
}
public void print() {
System.out.print("ConcretePrototype2: { attr3: " + attr3 + ", attr4: [");
for (int i : attr4) {
System.out.print(i + ", ");
}
System.out.println("] }");
}
}
// Prototype Factory
class PrototypeFactory {
private static Map<String, Prototype> prototypes = new HashMap<>();
static void registerPrototype(String name, Prototype prototype) {
prototypes.put(name, prototype);
}
static Prototype createPrototype(String name) {
Prototype prototype = prototypes.get(name);
if (prototype != null) {
return prototype.clone();
}
return null;
}
}
// Client code
public class Main {
public static void main(String[] args) {
// Register prototypes
PrototypeFactory.registerPrototype("prototype1", new ConcretePrototype1(10, "foo"));
PrototypeFactory.registerPrototype("prototype2", new ConcretePrototype2(3.14f, new int[]{1, 2, 3}));
// Clone prototypes
Prototype clone1 = PrototypeFactory.createPrototype("prototype1");
Prototype clone2 = PrototypeFactory.createPrototype("prototype2");
// Output cloned objects
if (clone1 instanceof ConcretePrototype1) {
((ConcretePrototype1) clone1).print();
}
if (clone2 instanceof ConcretePrototype2) {
((ConcretePrototype2) clone2).print();
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern/cpp/main.cpp | #include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
// Prototype interface
class Prototype {
public:
virtual Prototype* clone() const = 0;
virtual ~Prototype() {}
};
// Concrete prototype 1
class ConcretePrototype1 : public Prototype {
private:
int attr1;
std::string attr2;
public:
ConcretePrototype1(int attr1, const std::string& attr2) : attr1(attr1), attr2(attr2) {}
Prototype* clone() const override {
return new ConcretePrototype1(attr1, attr2);
}
void print() const {
std::cout << "ConcretePrototype1: { attr1: " << attr1 << ", attr2: " << attr2 << " }" << std::endl;
}
};
// Concrete prototype 2
class ConcretePrototype2 : public Prototype {
private:
float attr3;
std::vector<int> attr4;
public:
ConcretePrototype2(float attr3, const std::vector<int>& attr4) : attr3(attr3), attr4(attr4) {}
Prototype* clone() const override {
return new ConcretePrototype2(attr3, attr4);
}
void print() const {
std::cout << "ConcretePrototype2: { attr3: " << attr3 << ", attr4: [";
for (const auto& item : attr4) {
std::cout << item << ", ";
}
std::cout << "] }" << std::endl;
}
};
// Prototype Factory
class PrototypeFactory {
private:
static std::unordered_map<std::string, Prototype*> prototypes;
public:
static void registerPrototype(const std::string& name, Prototype* prototype) {
prototypes[name] = prototype;
}
static Prototype* createPrototype(const std::string& name) {
if (prototypes.find(name) != prototypes.end()) {
return prototypes[name]->clone();
}
return nullptr;
}
};
std::unordered_map<std::string, Prototype*> PrototypeFactory::prototypes;
// Client code
int main() {
// Register prototypes
PrototypeFactory::registerPrototype("prototype1", new ConcretePrototype1(10, "foo"));
PrototypeFactory::registerPrototype("prototype2", new ConcretePrototype2(3.14, {1, 2, 3}));
// Clone prototypes
Prototype* clone1 = PrototypeFactory::createPrototype("prototype1");
Prototype* clone2 = PrototypeFactory::createPrototype("prototype2");
// Output cloned objects
if (clone1) {
dynamic_cast<ConcretePrototype1*>(clone1)->print();
delete clone1;
}
if (clone2) {
dynamic_cast<ConcretePrototype2*>(clone2)->print();
delete clone2;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/prototype-pattern/python/prototype_pattern.py | from typing import Dict, Any, Type
class Prototype:
def clone(self) -> "Prototype":
raise NotImplementedError("clone method must be implemented by subclasses")
class ConcretePrototype1(Prototype):
def __init__(self, attr1: int, attr2: str):
self.attr1 = attr1
self.attr2 = attr2
def clone(self) -> "ConcretePrototype1":
return ConcretePrototype1(self.attr1, self.attr2)
class ConcretePrototype2(Prototype):
def __init__(self, attr3: float, attr4: list):
self.attr3 = attr3
self.attr4 = attr4
def clone(self) -> "ConcretePrototype2":
return ConcretePrototype2(self.attr3, self.attr4)
class PrototypeFactory:
_prototypes: Dict[str, Type[Prototype]] = {}
@classmethod
def register_prototype(cls, name: str, prototype: Type[Prototype]) -> None:
cls._prototypes[name] = prototype
@classmethod
def create_prototype(cls, name: str) -> Prototype:
prototype = cls._prototypes.get(name)
if not prototype:
raise ValueError(f"No prototype registered with name '{name}'")
return prototype.clone()
# Client code
if __name__ == "__main__":
# Register prototypes
PrototypeFactory.register_prototype("prototype1", ConcretePrototype1(10, "foo"))
PrototypeFactory.register_prototype("prototype2", ConcretePrototype2(3.14, [1, 2, 3]))
# Clone prototypes
clone1 = PrototypeFactory.create_prototype("prototype1")
clone2 = PrototypeFactory.create_prototype("prototype2")
# Output cloned objects
print(f"Clone 1: {clone1.__dict__}")
print(f"Clone 2: {clone2.__dict__}")
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern/java/Main.java | // Component interface
interface Coffee {
double cost();
}
// Concrete component
class SimpleCoffee implements Coffee {
public double cost() {
return 1.0;
}
}
// Decorator class
abstract class CoffeeDecorator implements Coffee {
protected Coffee coffee;
public CoffeeDecorator(Coffee coffee) {
this.coffee = coffee;
}
public double cost() {
return coffee.cost();
}
}
// Concrete decorators
class Milk extends CoffeeDecorator {
public Milk(Coffee coffee) {
super(coffee);
}
public double cost() {
return super.cost() + 0.5;
}
}
class Sugar extends CoffeeDecorator {
public Sugar(Coffee coffee) {
super(coffee);
}
public double cost() {
return super.cost() + 0.2;
}
}
// Client code
public class Main {
public static void main(String[] args) {
Coffee coffee = new SimpleCoffee();
System.out.println("Cost of simple coffee: " + coffee.cost());
coffee = new Milk(coffee);
System.out.println("Cost of coffee with milk: " + coffee.cost());
coffee = new Sugar(coffee);
System.out.println("Cost of coffee with sugar: " + coffee.cost());
coffee = new Sugar(new Milk(new SimpleCoffee()));
System.out.println("Cost of coffee with milk and sugar: " + coffee.cost());
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern/cpp/main.cpp | #include <iostream>
// Component interface
class Coffee {
public:
virtual double cost() const = 0;
virtual ~Coffee() {}
};
// Concrete component
class SimpleCoffee : public Coffee {
public:
double cost() const override {
return 1.0;
}
};
// Decorator class
class CoffeeDecorator : public Coffee {
protected:
Coffee* coffee;
public:
CoffeeDecorator(Coffee* coffee) : coffee(coffee) {}
virtual double cost() const override {
return coffee->cost();
}
virtual ~CoffeeDecorator() {
delete coffee;
}
};
// Concrete decorators
class Milk : public CoffeeDecorator {
public:
Milk(Coffee* coffee) : CoffeeDecorator(coffee) {}
double cost() const override {
return coffee->cost() + 0.5;
}
};
class Sugar : public CoffeeDecorator {
public:
Sugar(Coffee* coffee) : CoffeeDecorator(coffee) {}
double cost() const override {
return coffee->cost() + 0.2;
}
};
// Client code
int main() {
Coffee* coffee = new SimpleCoffee();
std::cout << "Cost of simple coffee: " << coffee->cost() << std::endl;
coffee = new Milk(coffee);
std::cout << "Cost of coffee with milk: " << coffee->cost() << std::endl;
coffee = new Sugar(coffee);
std::cout << "Cost of coffee with sugar: " << coffee->cost() << std::endl;
coffee = new Sugar(new Milk(new SimpleCoffee()));
std::cout << "Cost of coffee with milk and sugar: " << coffee->cost() << std::endl;
delete coffee;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/decorator-pattern/python/decorator_pattern.py | from abc import ABC, abstractmethod
# Component interface
class Coffee(ABC):
@abstractmethod
def cost(self) -> float:
pass
# Concrete component
class SimpleCoffee(Coffee):
def cost(self) -> float:
return 1.0
# Decorator class
class CoffeeDecorator(Coffee):
def __init__(self, coffee: Coffee) -> None:
self._coffee = coffee
def cost(self) -> float:
return self._coffee.cost()
# Concrete decorators
class Milk(CoffeeDecorator):
def cost(self) -> float:
return self._coffee.cost() + 0.5
class Sugar(CoffeeDecorator):
def cost(self) -> float:
return self._coffee.cost() + 0.2
# Client code
if __name__ == "__main__":
coffee = SimpleCoffee()
print("Cost of simple coffee:", coffee.cost())
coffee_with_milk = Milk(coffee)
print("Cost of coffee with milk:", coffee_with_milk.cost())
coffee_with_sugar = Sugar(coffee)
print("Cost of coffee with sugar:", coffee_with_sugar.cost())
coffee_with_milk_and_sugar = Sugar(Milk(coffee))
print("Cost of coffee with milk and sugar:", coffee_with_milk_and_sugar.cost())
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/java/Builder.java | public abstract class Builder {
public abstract void buildPart1(String part1);
public abstract void buildPart2(String part2);
public abstract void buildPart3(String part3);
public abstract Product getResult();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/java/Product.java | public class Product {
private String part1;
private String part2;
private String part3;
public Product(String part1, String part2, String part3) {
this.part1 = part1;
this.part2 = part2;
this.part3 = part3;
}
@Override
public String toString() {
return "Part 1: " + part1 + ", Part 2: " + part2 + ", Part 3: " + part3;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
director.construct();
Product product = builder.getResult();
System.out.println(product);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/java/ConcreteBuilder.java | public class ConcreteBuilder extends Builder {
private Product product;
public ConcreteBuilder() {
this.reset();
}
public void reset() {
this.product = new Product("", "", "");
}
@Override
public void buildPart1(String part1) {
this.product = new Product(part1, this.product.toString().split(", Part 2: ")[1].split(", Part 3: ")[0], this.product.toString().split(", Part 3: ")[1]);
}
@Override
public void buildPart2(String part2) {
this.product = new Product(this.product.toString().split("Part 1: ")[1].split(", Part 2: ")[0], part2, this.product.toString().split(", Part 3: ")[1]);
}
@Override
public void buildPart3(String part3) {
this.product = new Product(this.product.toString().split("Part 1: ")[1].split(", Part 2: ")[0], this.product.toString().split(", Part 2: ")[1].split(", Part 3: ")[0], part3);
}
@Override
public Product getResult() {
Product product = this.product;
this.reset();
return product;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/java/Director.java | public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void construct() {
this.builder.buildPart1("Part 1 built");
this.builder.buildPart2("Part 2 built");
this.builder.buildPart3("Part 3 built");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/cpp/Director.h | #ifndef DIRECTOR_H
#define DIRECTOR_H
#include "Builder.h"
class Director {
public:
Director(Builder* builder) : builder_(builder) {}
void construct() {
builder_->buildPart1("Part 1 built");
builder_->buildPart2("Part 2 built");
builder_->buildPart3("Part 3 built");
}
private:
Builder* builder_;
};
#endif // DIRECTOR_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/cpp/ConcreteBuilder.h | #ifndef CONCRETE_BUILDER_H
#define CONCRETE_BUILDER_H
#include "Builder.h"
class ConcreteBuilder : public Builder {
public:
ConcreteBuilder() {
reset();
}
void reset() {
product_ = Product();
}
void buildPart1(const std::string& part1) override {
product_.setPart1(part1);
}
void buildPart2(const std::string& part2) override {
product_.setPart2(part2);
}
void buildPart3(const std::string& part3) override {
product_.setPart3(part3);
}
Product getResult() override {
Product result = product_;
reset();
return result;
}
private:
Product product_;
};
#endif // CONCRETE_BUILDER_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/cpp/main.cpp | #include <iostream>
#include "ConcreteBuilder.h"
#include "Director.h"
int main() {
ConcreteBuilder builder;
Director director(&builder);
director.construct();
Product product = builder.getResult();
product.display();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/cpp/Product.h | #ifndef PRODUCT_H
#define PRODUCT_H
#include <string>
#include <iostream>
class Product {
public:
Product(const std::string& part1 = "", const std::string& part2 = "", const std::string& part3 = "")
: part1_(part1), part2_(part2), part3_(part3) {}
void setPart1(const std::string& part1) { part1_ = part1; }
void setPart2(const std::string& part2) { part2_ = part2; }
void setPart3(const std::string& part3) { part3_ = part3; }
void display() const {
std::cout << "Part 1: " << part1_ << ", Part 2: " << part2_ << ", Part 3: " << part3_ << std::endl;
}
private:
std::string part1_;
std::string part2_;
std::string part3_;
};
#endif // PRODUCT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/cpp/Builder.h | #ifndef BUILDER_H
#define BUILDER_H
#include "Product.h"
class Builder {
public:
virtual ~Builder() {}
virtual void buildPart1(const std::string& part1) = 0;
virtual void buildPart2(const std::string& part2) = 0;
virtual void buildPart3(const std::string& part3) = 0;
virtual Product getResult() = 0;
};
#endif // BUILDER_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/builder-pattern/python/builder_pattern.py | from abc import ABC, abstractmethod
from typing import Optional
# Product
class Product:
def __init__(self, part1: str, part2: str, part3: str) -> None:
self.part1 = part1
self.part2 = part2
self.part3 = part3
def __str__(self) -> str:
return f"Part 1: {self.part1}, Part 2: {self.part2}, Part 3: {self.part3}"
# Builder interface
class Builder(ABC):
@abstractmethod
def build_part1(self, part1: str) -> None:
pass
@abstractmethod
def build_part2(self, part2: str) -> None:
pass
@abstractmethod
def build_part3(self, part3: str) -> None:
pass
@abstractmethod
def get_result(self) -> Product:
pass
# Concrete builder
class ConcreteBuilder(Builder):
def __init__(self) -> None:
self.product: Optional[Product] = None
self.reset()
def reset(self) -> None:
self.product = Product(part1="", part2="", part3="")
def build_part1(self, part1: str) -> None:
self.product.part1 = part1
def build_part2(self, part2: str) -> None:
self.product.part2 = part2
def build_part3(self, part3: str) -> None:
self.product.part3 = part3
def get_result(self) -> Product:
product = self.product
self.reset()
return product
# Director
class Director:
def __init__(self, builder: Builder) -> None:
self.builder = builder
def construct(self) -> None:
self.builder.build_part1("Part 1 built")
self.builder.build_part2("Part 2 built")
self.builder.build_part3("Part 3 built")
# Client code
if __name__ == "__main__":
builder = ConcreteBuilder()
director = Director(builder)
director.construct()
product = builder.get_result()
print(product)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/Light.java | // Receiver
public class Light {
public void turnOn() {
System.out.println("Light is on");
}
public void turnOff() {
System.out.println("Light is off");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/Command.java | // Command interface
public interface Command {
void execute();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/TurnOffCommand.java | // Concrete command
public class TurnOffCommand implements Command {
private Light light;
public TurnOffCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOff();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
Light light = new Light();
Command turnOnCommand = new TurnOnCommand(light);
Command turnOffCommand = new TurnOffCommand(light);
RemoteControl remoteControl = new RemoteControl();
// Pressing turn on button
remoteControl.setCommand(turnOnCommand);
remoteControl.pressButton();
// Pressing turn off button
remoteControl.setCommand(turnOffCommand);
remoteControl.pressButton();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/RemoteControl.java | // Invoker
public class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
if (command != null) {
command.execute();
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/java/TurnOnCommand.java | // Concrete command
public class TurnOnCommand implements Command {
private Light light;
public TurnOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOn();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/TurnOnCommand.h | #ifndef TURNONCOMMAND_H
#define TURNONCOMMAND_H
#include "Command.h"
#include "Light.h"
// Concrete command
class TurnOnCommand : public Command {
public:
explicit TurnOnCommand(const Light& light) : light_(light) {}
void execute() const override {
light_.turnOn();
}
private:
const Light& light_;
};
#endif // TURNONCOMMAND_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/RemoteControl.h | #ifndef REMOTECONTROL_H
#define REMOTECONTROL_H
#include "Command.h"
// Invoker
class RemoteControl {
public:
void setCommand(Command* command) {
command_ = command;
}
void pressButton() const {
if (command_) {
command_->execute();
}
}
private:
Command* command_ = nullptr;
};
#endif // REMOTECONTROL_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/main.cpp | #include <iostream>
#include "Light.h"
#include "TurnOnCommand.h"
#include "TurnOffCommand.h"
#include "RemoteControl.h"
int main() {
Light light;
TurnOnCommand turnOnCommand(light);
TurnOffCommand turnOffCommand(light);
RemoteControl remoteControl;
// Pressing turn on button
remoteControl.setCommand(&turnOnCommand);
remoteControl.pressButton();
// Pressing turn off button
remoteControl.setCommand(&turnOffCommand);
remoteControl.pressButton();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/TurnOffCommand.h | #ifndef TURNOFFCOMMAND_H
#define TURNOFFCOMMAND_H
#include "Command.h"
#include "Light.h"
// Concrete command
class TurnOffCommand : public Command {
public:
explicit TurnOffCommand(const Light& light) : light_(light) {}
void execute() const override {
light_.turnOff();
}
private:
const Light& light_;
};
#endif // TURNOFFCOMMAND_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/Command.h | #ifndef COMMAND_H
#define COMMAND_H
// Command interface
class Command {
public:
virtual ~Command() = default;
virtual void execute() const = 0;
};
#endif // COMMAND_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/cpp/Light.h | #ifndef LIGHT_H
#define LIGHT_H
#include <iostream>
// Receiver
class Light {
public:
void turnOn() const {
std::cout << "Light is on" << std::endl;
}
void turnOff() const {
std::cout << "Light is off" << std::endl;
}
};
#endif // LIGHT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/command-pattern/python/command_pattern.py | from abc import ABC, abstractmethod
from typing import Any, Protocol
# Receiver
class Light:
def turn_on(self) -> None:
print("Light is on")
def turn_off(self) -> None:
print("Light is off")
# Command interface
class Command(Protocol):
@abstractmethod
def execute(self) -> None:
pass
# Concrete command
class TurnOnCommand(Command):
def __init__(self, light: Light) -> None:
self.light = light
def execute(self) -> None:
self.light.turn_on()
# Concrete command
class TurnOffCommand(Command):
def __init__(self, light: Light) -> None:
self.light = light
def execute(self) -> None:
self.light.turn_off()
# Invoker
class RemoteControl:
def __init__(self) -> None:
self.command: Command
def set_command(self, command: Command) -> None:
self.command = command
def press_button(self) -> None:
self.command.execute()
# Client code
if __name__ == "__main__":
light = Light()
turn_on_command = TurnOnCommand(light)
turn_off_command = TurnOffCommand(light)
remote_control = RemoteControl()
# Pressing turn on button
remote_control.set_command(turn_on_command)
remote_control.press_button()
# Pressing turn off button
remote_control.set_command(turn_off_command)
remote_control.press_button()
|
0 | repos/exploratory-tech-studio/tech-studio-projects | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative_finance_docs.md | # Financial Engineering Lab Documentation
Welcome to the Financial Engineering Lab! This documentation provides information about various topics and trends in the financial industry, with a focus on quantitative trading, portfolio optimization, data analysis, and related subjects.
## Quantitative Trading
Quantitative trading involves using mathematical and statistical models to analyze market data and make trading decisions. Here are some key areas and resources related to quantitative trading:
- **Algorithmic Trading**: Automated trading strategies based on predefined rules or algorithms.
- [QuantConnect](https://www.quantconnect.com/): Algorithmic trading platform with extensive backtesting and live trading capabilities.
- [Quantpedia](https://www.quantpedia.com/): Quantitative trading strategies database with detailed descriptions and research papers.
- **High-Frequency Trading (HFT)**: Trading strategies that exploit short-term market inefficiencies with high-speed trading algorithms.
- [HFT Review](https://www.hftreview.com/): News and insights into high-frequency trading developments and technology.
- **Market Microstructure**: Study of the dynamics and mechanisms of financial markets, including order flow, liquidity, and price formation.
- [Market Microstructure Knowledge Center](https://www.cmegroup.com/education/market-microstructure-knowledge-center.html): Educational resources on market microstructure from CME Group.
- **Self-study becoming a Quant**: Self-Study plan for Becoming a Quantitative Trader
- [Beginner's Guide to Quantitative Trading](https://www.quantstart.com/articles/Beginners-Guide-to-Quantitative-Trading/)
- [How to Identify Algorithmic Trading Strategies](https://www.quantstart.com/articles/How-to-Identify-Algorithmic-Trading-Strategies/)
- [Successful Backtesting of Algorithmic Trading Strategies - Part I](https://www.quantstart.com/articles/Successful-Backtesting-of-Algorithmic-Trading-Strategies-Part-I/)
- [Successful Backtesting of Algorithmic Trading Strategies - Part II](https://www.quantstart.com/articles/Successful-Backtesting-of-Algorithmic-Trading-Strategies-Part-II/)
## Portfolio Optimization
Portfolio optimization aims to construct portfolios that achieve the best trade-off between risk and return. Here are some resources and techniques for portfolio optimization:
- **Modern Portfolio Theory (MPT)**: Framework for optimizing portfolios based on mean-variance analysis.
- [Portfolio Optimization with Python](https://pyportfolioopt.readthedocs.io/en/latest/): Python library for portfolio optimization.
- **Risk Parity**: Portfolio allocation strategy that equalizes risk contributions across assets.
- [Introduction to Risk Parity](https://www.investopedia.com/terms/r/riskparity.asp): Investopedia article explaining risk parity concepts.
- **Factor Investing**: Strategy that focuses on investing in factors that are expected to generate excess returns.
- [FactorInvestor.com](https://www.factorinvestor.com/): Educational platform on factor investing and factor-based portfolio construction.
## Data Analysis and Machine Learning
Data analysis and machine learning techniques are increasingly used in the financial industry for predictive modeling, pattern recognition, and decision support. Here are some relevant resources:
- **Python for Finance**: Python programming language and libraries (e.g., pandas, numpy, scikit-learn) are widely used for financial data analysis and machine learning.
- [Python for Finance](https://github.com/yhilpisch/py4fi): GitHub repository with code examples from the book "Python for Finance" by Yves Hilpisch.
- **Deep Learning in Finance**: Application of deep learning models (e.g., neural networks) to financial data for prediction and risk management.
- [Deep Learning in Finance](https://www.deeplearning.ai/ai-for-finance/): Online course on deep learning techniques for finance from deeplearning.ai.
- **Reinforcement Learning for Trading**: Use of reinforcement learning algorithms to develop autonomous trading agents.
- [Reinforcement Learning for Trading](https://github.com/andrecianflone/Reinforcement_learning_for_trading): GitHub repository with code examples and tutorials on reinforcement learning for trading.
## Artificial Intelligence and Financial Technology (FinTech)
Artificial intelligence (AI) and financial technology (FinTech) are transforming the financial industry, enabling innovation in areas such as risk management, fraud detection, and customer service. Here are some relevant resources:
- **FinTech Innovation**: Explore emerging technologies and startups disrupting traditional financial services.
- [FinTech Magazine](https://fintechmagazine.com/): Online publication covering FinTech news, trends, and insights.
- **AI in Finance**: Applications of artificial intelligence and machine learning in various financial domains.
- [AI in Finance Summit](https://www.re-work.co/events/ai-finance-summit-london): Summit focused on AI applications in finance, featuring industry experts and case studies.
- **Blockchain and Cryptocurrency**: Distributed ledger technology and digital currencies are reshaping payment systems and asset management.
- [Blockchain.com](https://www.blockchain.com/): Platform for exploring blockchain data and cryptocurrency markets.
## Financial Data in the Industry
Financial data plays a crucial role in the financial industry, providing insights into market trends, investment opportunities, risk analysis, and more. Here are some key points to consider:
### Types of Financial Data
- **Market Data**: Historical or real-time market data used for financial analysis, backtesting trading strategies, or risk management.
- **Fundamental Data**: Information about a company's financial performance, such as revenue, earnings, balance sheets, and cash flow.
- **Alternative Data**: Non-traditional sources of data used for investment analysis, such as satellite imagery, social media sentiment, web traffic, and credit card transactions.
- **Economic Data**: Indicators of macroeconomic conditions, such as GDP growth, unemployment rates, inflation, and interest rates.
- **Additional Data Types**: Historical prices, simulation inputs
, reference datasets, sample data, and external data sources relevant to financial projects.
### Importance of Financial Data
- **Decision Making**: Financial data informs investment decisions, risk management strategies, and business operations.
- **Performance Evaluation**: Investors and analysts use financial data to assess the performance of assets, portfolios, and companies.
- **Regulatory Compliance**: Financial institutions must adhere to regulatory requirements related to data reporting, transparency, and risk management.
### Challenges in Financial Data Analysis
- **Data Quality**: Ensuring the accuracy, completeness, and timeliness of financial data.
- **Data Integration**: Integrating data from disparate sources can be complex and require robust data management processes.
- **Data Security**: Financial data is sensitive and subject to regulatory requirements regarding data privacy and security.
|
0 | repos/exploratory-tech-studio/tech-studio-projects | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/financial_reporting_docs.md | # US GAAP
## 1. **ASC Standards Understanding**
- **Description**: Understanding the Generally Accepted Accounting Principles (GAAP) in the United States, particularly the Accounting Standards Codification (ASC), is crucial for compliance with U.S. accounting regulations.
- **Resources**:
- [FASB Website](https://www.fasb.org/)
- ASC Standards Documentation
## 2. **Financial Accounting Knowledge**
- **Description**: A solid foundation in financial accounting principles and practices is necessary for accurately implementing accounting standards and performing financial analyses.
- **Resources**:
- Financial Accounting textbooks and reference materials
- Accounting professional certifications (e.g., CPA, ACCA)
## 3. **Segment Reporting and EPS Understanding**
- **Description**: Familiarity with segment reporting requirements and earnings per share (EPS) calculations, as outlined in ASC 280 and ASC 260 respectively, is essential for accurate financial reporting.
- **Resources**:
- ASC 280 and ASC 260 Documentation
- Accounting textbooks covering segment reporting and EPS
- Online resources and articles on segment reporting and EPS
## 4. **Financial Modeling Skills**
- **Description**: Proficiency in financial modeling techniques is beneficial for performing complex accounting calculations and analyses.
- **Resources**:
- Financial modeling courses (e.g., Wall Street Prep, CFI)
- Excel tutorials and courses
- Financial modeling templates and examples
## 5. **Actuarial Valuation Knowledge (for Pension Accounting)**
- **Description**: Understanding actuarial valuation methods and assumptions is crucial for estimating pension obligations and other postretirement benefits, as governed by ASC 715 and ASC 715-60.
- **Resources**:
- Actuarial textbooks and reference materials
- Actuarial professional certifications (e.g., ASA, FSA)
- Actuarial modeling software (e.g., AXIS, Prophet)
----
# IFRS
## 1. **IFRS Standards Implementation**
- **Description**: Implementing International Financial Reporting Standards (IFRS) requires a deep understanding of accounting principles and standards set by the International Accounting Standards Board (IASB).
- **Resources**:
- [IASB Website](https://www.ifrs.org/)
- IFRS Standards Documentation
## 2. **Financial Accounting Knowledge**
- **Description**: A solid foundation in financial accounting principles and practices is necessary for accurately implementing accounting standards and performing financial analyses.
- **Resources**:
- Financial Accounting textbooks and reference materials
- Accounting professional certifications (e.g., ACCA, CPA)
## 3. **Segment Reporting and EPS Understanding**
- **Description**: Familiarity with segment reporting requirements and earnings per share (EPS) calculations is essential for accurate financial reporting.
- **Resources**:
- IFRS Standards related to segment reporting and EPS
- Accounting textbooks covering segment reporting and EPS
- Online resources and articles on segment reporting and EPS
## 4. **Actuarial Valuation Knowledge (for Pension Accounting)**
- **Description**: Understanding actuarial valuation methods and assumptions is crucial for estimating pension obligations and other postretirement benefits, as governed by IFRS standards.
- **Resources**:
- Actuarial textbooks and reference materials
- Actuarial professional certifications (e.g., ASA, FIA)
- Actuarial modeling software (e.g., AXIS, Prophet)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/portfolio-optimization-tool/portfolio_optimization.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""portfolio_optimization.py"""
import numpy as np
from scipy.optimize import minimize
def main() -> None:
"""Driving code."""
# Example usage:
returns = np.array([0.10, 0.08, 0.12])
cov_matrix = np.array([[0.005, -0.010, 0.004],
[-0.010, 0.040, -0.002],
[0.004, -0.002, 0.023]])
risk_free_rate = 0.03
optimized_weights = optimize_portfolio(returns, cov_matrix, risk_free_rate)
print("Optimized Portfolio Weights:", optimized_weights)
return None
def calculate_portfolio_return(weights, returns):
"""Calculate the return value of a portfolio."""
return np.sum(weights * returns)
def calculate_portfolio_volatility(weights, cov_matrix):
"""Calculate the volatility of a portfolio."""
return np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
def calculate_sharpe_ratio(weights, returns, cov_matrix, risk_free_rate):
"""Calculate the sharp ratio."""
portfolio_return = calculate_portfolio_return(weights, returns)
portfolio_volatility = calculate_portfolio_volatility(weights, cov_matrix)
return (portfolio_return - risk_free_rate) / portfolio_volatility
def optimize_portfolio(returns, cov_matrix, risk_free_rate):
"""Perform portfolio optimization."""
num_assets = len(returns)
initial_weights = np.ones(num_assets) / num_assets
bounds = tuple((0, 1) for _ in range(num_assets))
constraints = ({'type': 'eq', 'fun': lambda weights: np.sum(weights) - 1})
result = minimize(lambda weights: -calculate_sharpe_ratio(weights, returns, cov_matrix, risk_free_rate),
initial_weights, method='SLSQP', bounds=bounds, constraints=constraints)
return result.x
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/relative-strength-index | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/relative-strength-index/python/scratchwork.md | The Relative Strength Index (RSI) is a momentum oscillator that measures the speed and change of price movements. It oscillates between 0 and 100 and is typically used to identify overbought or oversold conditions in a market. The RSI trading strategy is based on the principle that when the RSI value exceeds certain thresholds, it may indicate potential trend reversals or corrections in price.
### How the Relative Strength Index (RSI) Works:
1. **Calculation of RSI**: RSI is calculated based on the average gain and average loss over a specified period, usually 14 days for traditional settings. The formula for calculating RSI is:
\[
\text{RSI} = 100 - \left( \frac{100}{1 + RS} \right)
\]
where RS (Relative Strength) is the ratio of average gain to average loss over the specified period.
2. **Interpretation of RSI Values**:
- RSI values above 70 are typically considered overbought, suggesting that the asset may be overvalued and a potential reversal or correction may occur.
- RSI values below 30 are typically considered oversold, suggesting that the asset may be undervalued and a potential reversal or bounce-back may occur.
3. **Trading Signals**:
- **Overbought Conditions**: When the RSI value crosses above the 70 threshold, it may indicate that the asset is overbought, and a reversal or correction in price may be imminent. Traders may consider selling or shorting the asset.
- **Oversold Conditions**: When the RSI value crosses below the 30 threshold, it may indicate that the asset is oversold, and a potential reversal or bounce-back in price may occur. Traders may consider buying or going long on the asset.
4. **Confirmation and Risk Management**:
- RSI signals are more reliable when they are confirmed by other technical indicators or chart patterns.
- Traders should always use proper risk management techniques, such as setting stop-loss orders, to manage their positions.
5. **Limitations**:
- RSI is a lagging indicator, meaning it may not always provide timely signals, especially in strongly trending markets.
- False signals can occur, especially in choppy or range-bound markets.
In summary, the RSI trading strategy is based on identifying overbought and oversold conditions in a market using the Relative Strength Index indicator. Traders use RSI signals to make buy or sell decisions, but they should always consider other factors and use proper risk management techniques when executing trades.
### Sources:
[https://en.wikipedia.org/wiki/Relative_strength_index](https://en.wikipedia.org/wiki/Relative_strength_index) |
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/relative-strength-index | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/relative-strength-index/python/relative_strength_index.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate RSI
window = 14
delta = np.diff(prices)
gain = np.where(delta > 0, delta, 0)
loss = np.where(delta < 0, -delta, 0)
avg_gain = np.mean(gain[:window])
avg_loss = np.mean(loss[:window])
rs = avg_gain / avg_loss
rsi = 100 - (100 / (1 + rs))
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(range(1, n), rsi, label='RSI')
plt.axhline(y=70, color='r', linestyle='--', label='Overbought (70)')
plt.axhline(y=30, color='g', linestyle='--', label='Oversold (30)')
plt.legend()
plt.title('Relative Strength Index (RSI) Simulation')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/trendline-breakout | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/trendline-breakout/python/trendline_breakout_simulation.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate trendline using linear regression
trendline = np.polyfit(range(n), prices, 1)
regression_line = np.polyval(trendline, range(n))
# Identify breakout points
breakout_points = np.where(prices > regression_line)[0]
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(regression_line, label='Trendline', linestyle='--')
plt.scatter(breakout_points, prices[breakout_points], color='green', marker='^', label='Breakout Point')
plt.legend()
plt.title('Trendline Breakout Simulation')
plt.xlabel('Time')
plt.ylabel('Price')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/trendline-breakout | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/trendline-breakout/python/scratchwork.md | ### Trendline Breakout Simulation Explanation:
#### Overview:
The Trendline Breakout strategy aims to identify potential trend reversals by analyzing the price movements relative to a trendline. This strategy is based on the concept that prices tend to follow trends, and when they break above or below a trendline, it may indicate the start of a new trend.
#### Implementation:
1. **Generate Random Price Data**: Initially, we generate random price data. This could represent the price of a financial instrument over a period of time.
2. **Calculate Trendline**: Next, we calculate a trendline using linear regression. Linear regression fits a straight line to the data points in such a way that it minimizes the sum of the squared differences between the actual values and the predicted values.
3. **Identify Breakout Points**: We identify breakout points by comparing the actual prices to the values predicted by the trendline. When the price breaks above the trendline, it indicates a potential uptrend, and when it breaks below the trendline, it indicates a potential downtrend.
4. **Plot Results**: Finally, we plot the price data along with the trendline and breakout points to visualize the potential trend reversals.
#### How it Works:
- **Trend Identification**: The Trendline Breakout strategy relies on identifying trends in price movements. A trendline is drawn by fitting a line to the price data. If the price consistently moves above the trendline, it suggests an uptrend, and if it consistently moves below the trendline, it suggests a downtrend.
- **Breakout Points**: Breakout points occur when the price breaks above or below the trendline. This indicates a potential reversal of the current trend. Traders often interpret breakouts as signals to enter new positions in the direction of the breakout, anticipating a continuation of the trend.
- **Confirmation**: Breakout signals are more reliable when accompanied by other confirming factors, such as increasing trading volume or the convergence of multiple technical indicators. Traders may also use additional analysis techniques to confirm the validity of a breakout signal before entering a trade.
In summary, the Trendline Breakout strategy is a popular method for identifying potential trend reversals in price movements. By analyzing the relationship between actual prices and a trendline, traders can seek opportunities to enter new positions and capitalize on emerging trends in the market.
#### Sources:
[https://algorush.com/wiki/trend-breakout-system-overview](https://algorush.com/wiki/trend-breakout-system-overview)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-convergence-devergence | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-convergence-devergence/python/moving_avge_converg_deverg.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate MACD
short_window = 12
long_window = 26
signal_window = 9
short_ema = np.convolve(prices, np.ones(short_window)/short_window, mode='valid')
long_ema = np.convolve(prices, np.ones(long_window)/long_window, mode='valid')
macd_line = short_ema - long_ema
signal_line = np.convolve(macd_line, np.ones(signal_window)/signal_window, mode='valid')
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(range(long_window-1, n), macd_line, label='MACD Line')
plt.plot(range(long_window-1, n), signal_line, label='Signal Line')
plt.legend()
plt.title('MACD (Moving Average Convergence Divergence) Simulation')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-crossover | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-crossover/python/moving_average_crossover_simulation.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate moving averages
short_window = 10
long_window = 30
short_ma = np.convolve(prices, np.ones(short_window)/short_window, mode='valid')
long_ma = np.convolve(prices, np.ones(long_window)/long_window, mode='valid')
# Generate signals
buy_signal = (short_ma > long_ma).astype(int)
sell_signal = (short_ma < long_ma).astype(int)
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(short_ma, label=f'{short_window}-Day Moving Average')
plt.plot(long_ma, label=f'{long_window}-Day Moving Average')
plt.scatter(np.where(buy_signal == 1), prices[short_window-1:][buy_signal == 1], color='green', marker='^', label='Buy Signal')
plt.scatter(np.where(sell_signal == 1), prices[short_window-1:][sell_signal == 1], color='red', marker='v', label='Sell Signal')
plt.legend()
plt.title('Moving Average Crossover Simulation')
plt.xlabel('Time')
plt.ylabel('Price')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-crossover | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/trend-following-or-momentum-strategies/moving-average-crossover/python/scratchwork.md | The Moving Average Crossover trading strategy is a popular trend-following strategy used by traders to identify potential entry and exit points in the market. It involves the use of two moving averages with different periods, typically a short-term moving average and a long-term moving average. When the short-term moving average crosses above the long-term moving average, it generates a buy signal, indicating a potential uptrend. Conversely, when the short-term moving average crosses below the long-term moving average, it generates a sell signal, indicating a potential downtrend.
### How the Moving Average Crossover Strategy Works:
1. **Selection of Moving Averages**:
- The strategy typically uses two moving averages: a short-term moving average and a long-term moving average.
- Common combinations include the 50-day and 200-day moving averages, or the 20-day and 50-day moving averages, but traders may choose any periods based on their trading style and preferences.
2. **Identification of Crossover Points**:
- When the short-term moving average (e.g., 20-day MA) crosses above the long-term moving average (e.g., 50-day MA), it generates a bullish crossover signal, indicating a potential uptrend.
- When the short-term moving average crosses below the long-term moving average, it generates a bearish crossover signal, indicating a potential downtrend.
3. **Trading Signals**:
- **Bullish Crossover (Buy Signal)**: Traders interpret a bullish crossover as a signal to buy or enter a long position in the market, anticipating a potential uptrend.
- **Bearish Crossover (Sell Signal)**: Traders interpret a bearish crossover as a signal to sell or enter a short position in the market, anticipating a potential downtrend.
4. **Confirmation and Risk Management**:
- Traders often use additional technical indicators, chart patterns, or fundamental analysis to confirm the crossover signals and avoid false signals.
- Proper risk management techniques, such as setting stop-loss orders and position sizing, are essential to manage potential losses.
5. **Limitations**:
- Moving average crossovers may generate false signals, especially in choppy or ranging markets, leading to losses or whipsaws.
- The strategy may lag during strong trends, causing traders to enter or exit positions late.
### Example:
- **Bullish Crossover**: When the short-term moving average (e.g., 20-day MA) crosses above the long-term moving average (e.g., 50-day MA), it indicates that the recent price momentum is stronger than the longer-term trend, potentially signaling the start of an uptrend. Traders may interpret this as a signal to buy or enter a long position.
- **Bearish Crossover**: When the short-term moving average crosses below the long-term moving average, it indicates that the recent price momentum is weaker than the longer-term trend, potentially signaling the start of a downtrend. Traders may interpret this as a signal to sell or enter a short position.
### Sources:
[https://www.investopedia.com/terms/m/movingaverage.asp](https://www.investopedia.com/terms/m/movingaverage.asp) |
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/stochastic-oscillator | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/stochastic-oscillator/python/stochastic_oscillator_simulation.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Define parameters
window = 14
# Calculate Stochastic Oscillator
low_min = np.minimum.accumulate(prices)
high_max = np.maximum.accumulate(prices)
stochastic_oscillator = 100 * (prices - low_min) / (high_max - low_min)
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(range(window-1, n), stochastic_oscillator, label='Stochastic Oscillator')
plt.axhline(y=80, color='r', linestyle='--', label='Overbought (80)')
plt.axhline(y=20, color='g', linestyle='--', label='Oversold (20)')
plt.legend()
plt.title('Stochastic Oscillator Simulation')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/bollinger-bands | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/bollinger-bands/python/bollinger_bands_simulation.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate moving average and standard deviation
window_size = 20
rolling_mean = np.convolve(prices, np.ones(window_size)/window_size, mode='valid')
rolling_std = np.std(prices[:window_size-1])
# Calculate upper and lower Bollinger Bands
upper_band = rolling_mean + 2 * rolling_std
lower_band = rolling_mean - 2 * rolling_std
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(rolling_mean, label='Rolling Mean')
plt.plot(upper_band, label='Upper Bollinger Band')
plt.plot(lower_band, label='Lower Bollinger Band')
plt.fill_between(range(window_size-1, n), upper_band, lower_band, color='gray', alpha=0.3)
plt.legend()
plt.title('Bollinger Bands Simulation')
plt.xlabel('Time')
plt.ylabel('Price')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/mean-reversion-channel | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/mean-reversion-channel/python/mean_reversion_channel_strategy.py | import numpy as np
import matplotlib.pyplot as plt
# Generate random price data
np.random.seed(0)
n = 100
prices = np.cumsum(np.random.randn(n))
# Calculate mean and standard deviation
window_size = 20
rolling_mean = np.convolve(prices, np.ones(window_size)/window_size, mode='valid')
rolling_std = np.std(prices[:window_size-1])
# Define channels
upper_channel = rolling_mean + rolling_std
lower_channel = rolling_mean - rolling_std
# Generate signals
buy_signal = (prices < lower_channel).astype(int)
sell_signal = (prices > upper_channel).astype(int)
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(prices, label='Price')
plt.plot(rolling_mean, label='Rolling Mean')
plt.plot(upper_channel, label='Upper Channel', linestyle='--')
plt.plot(lower_channel, label='Lower Channel', linestyle='--')
plt.scatter(np.where(buy_signal == 1), prices[buy_signal == 1], color='green', marker='^', label='Buy Signal')
plt.scatter(np.where(sell_signal == 1), prices[sell_signal == 1], color='red', marker='v', label='Sell Signal')
plt.legend()
plt.title('Mean-Reversion Channel Strategy Simulation')
plt.xlabel('Time')
plt.ylabel('Price')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/pairs-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/trading-strategies/mean-reversion-strategies/pairs-trading/python/pairs_trading_strategy.py | import numpy as np
import matplotlib.pyplot as plt
# Generate correlated random price data
np.random.seed(0)
n = 100
price_A = np.cumsum(np.random.randn(n))
price_B = price_A + np.random.randn(n)
# Calculate spread between prices
spread = price_A - price_B
# Define threshold for trading
entry_threshold = 1.5
exit_threshold = 0.5
# Initialize positions
positions = np.zeros(n)
# Pairs trading strategy
for i in range(1, n):
if spread[i] > entry_threshold:
positions[i] = -1 # Sell A, buy B
elif spread[i] < -entry_threshold:
positions[i] = 1 # Buy A, sell B
elif abs(spread[i]) < exit_threshold:
positions[i] = 0 # Exit positions
# Plot results
plt.figure(figsize=(10, 6))
plt.plot(price_A, label='Asset A')
plt.plot(price_B, label='Asset B')
plt.scatter(np.where(positions == -1), price_A[positions == -1], color='red', marker='v', label='Sell A, Buy B')
plt.scatter(np.where(positions == 1), price_A[positions == 1], color='green', marker='^', label='Buy A, Sell B')
plt.legend()
plt.title('Pairs Trading Simulation')
plt.xlabel('Time')
plt.ylabel('Price')
plt.show()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/market-sentiment-analysis/sentiment_analysis_financial_data.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""sentiment_analysis_financial_data.py
Description: A tool for analyzing market sentiment from news articles, social media, and other sources to predict market trends and sentiment shifts.
Technologies: Python for text processing and sentiment analysis using spaCy and VADER, Java for web scraping using Selenium, and C++ for sentiment analysis algorithms.
Folder Structure: projects/market_sentiment_analysis_tool/" -> provide afully working and functional example with fully working and docuemnted code
"""
import requests
from bs4 import BeautifulSoup
import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer
# initialize VADER sentiment analyzer
nltk.download('vader_lexicon')
sia = SentimentIntensityAnalyzer()
def main():
"""Driving code."""
# scraping BBC News
bbc_articles = scrape_news_website("https://www.bbc.com/news", "h3", "p")
print("BBC News Articles:")
for i, article in enumerate(bbc_articles, start=1):
print(f"Article {i}: {article['headline']}")
print(f"Summary: {article['summary']}")
sentiment_scores = analyze_sentiment(article['summary'])
print("Sentiment Scores:", sentiment_scores)
print()
# scraping CNN
cnn_articles = scrape_news_website("https://www.cnn.com/", "h3", "p")
print("CNN Articles:")
for i, article in enumerate(cnn_articles, start=1):
print(f"Article {i}: {article['headline']}")
print(f"Summary: {article['summary']}")
sentiment_scores = analyze_sentiment(article['summary'])
print("Sentiment Scores:", sentiment_scores)
print()
# scraping Reuters
reuters_articles = scrape_news_website("https://www.reuters.com/", "h3", "p")
print("Reuters Articles:")
for i, article in enumerate(reuters_articles, start=1):
print(f"Article {i}: {article['headline']}")
print(f"Summary: {article['summary']}")
sentiment_scores = analyze_sentiment(article['summary'])
print("Sentiment Scores:", sentiment_scores)
print()
# scraping The New York Times
nytimes_articles = scrape_news_website("https://www.nytimes.com/", "h2", "p")
print("The New York Times Articles:")
for i, article in enumerate(nytimes_articles, start=1):
print(f"Article {i}: {article['headline']}")
print(f"Summary: {article['summary']}")
sentiment_scores = analyze_sentiment(article['summary'])
print("Sentiment Scores:", sentiment_scores)
print()
def scrape_news_website(url, headline_tag, summary_tag) -> list:
"""Scrapper to scrape latest news from websites."""
response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")
articles = []
for article in soup.find_all("article"):
headline_element = article.find(headline_tag)
summary_element = article.find(summary_tag)
print("headline_element:", headline_element)
if headline_element and summary_element:
headline = headline_element.text.strip()
summary = summary_element.text.strip()
articles.append({"headline": headline, "summary": summary})
else:
# Skip this article if either headline or summary is not found
continue
return articles
def analyze_sentiment(text):
"""Perform sentiment analysis using VADER."""
sentiment_scores = sia.polarity_scores(text)
return sentiment_scores
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system/build.sh | #!/bin/bash
# Create build directory if it doesn't exist
mkdir -p build
# Navigate to the build directory
cd build
# Run CMake to generate build files
cmake ..
# Build the executable
make
# Optionally, move the executable to a different directory
# mv execution_simulation /path/to/destination
# Display completion message
echo "Build completed successfully"
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
project(ExecutionSimulation)
set(CMAKE_CXX_STANDARD 11)
add_executable(execution_simulation main.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system/python_draft/execution_simulation.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""execution_simulation.py
A simplified version of a simulation-based execution system with logging and a basic monitoring optimization system.
This example focuses on generating random trade signals and simulating their execution within a specified timeframe.
NOTE: The python file is a standalone and serves as a draft for later implementations.
"""
import time
import random
import logging
from typing import Literal, NoReturn
# Configure logging
logging.basicConfig(filename='execution_system_simulation.log', level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s')
def main() -> None:
"""Main program and entrypoint."""
try:
logging.info("Execution simulation started")
execution_loop()
except KeyboardInterrupt:
logging.info("Execution simulation stopped by user")
except Exception as e:
logging.exception(f"An error occurred during execution simulation: {e}")
return None
def generate_market_data() -> float:
"""Simulate the generation of random market data."""
return random.uniform(100, 200) # Placeholder for market data (e.g., stock price)
def analyze_market_data(market_data) -> Literal['BUY', 'SELL'] | None:
"""Analyze market data and rpompt user for trade decision."""
# placeholder for market analysis
# for demonstration, let's just print the market data
print(f"Market data: {market_data}")
# pfrompt user for trade decision
while True:
decision = input("Enter your trade decision (BUY or SELL): ").strip().upper()
if decision in ('BUY', 'SELL'):
return decision
else:
print("Invalid input. Please enter BUY or SELL.")
return None
def execute_trade(trade_signal) -> None:
"""Simulate order execution."""
logging.info(f"Executing trade: {trade_signal}")
# simulate order execution logic here
time.sleep(1) # Simulate order execution time
logging.info("Trade execution completed")
return None
def execution_loop() -> NoReturn:
"""Siulate execution loop."""
while True:
# generate random market data
market_data = generate_market_data()
# analyze market data and prompt user for trade decision
trade_decision = analyze_market_data(market_data)
logging.info(f"User trade decision: {trade_decision}")
# execute trade based on user decision
execute_trade(trade_decision)
# sleep for 10 minutes before next iteration
time.sleep(10) # 10 seconds (for demonstration)
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/execution-system/execution_simluation/execution_simulation.cpp | // cplusplus.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include <iostream>
#include <chrono>
#include <thread>
#include <random>
#include <fstream>
// Define trade signal types
enum class TradeSignal { BUY, SELL };
// Function to generate random market data
double generate_market_data() {
// Simulate random market data generation
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<double> dist(100, 200);
return dist(gen); // Placeholder for market data (e.g., stock price)
}
// Function to analyze market data and prompt user for trade decision
TradeSignal analyze_market_data(double market_data) {
// Placeholder for market analysis
// For demonstration, let's just print the market data
std::cout << "Market data: " << market_data << std::endl;
// Prompt user for trade decision
while (true) {
std::cout << "Enter your trade decision (BUY or SELL): ";
std::string decision;
std::cin >> decision;
if (decision == "BUY") {
return TradeSignal::BUY;
}
else if (decision == "SELL") {
return TradeSignal::SELL;
}
else {
std::cout << "Invalid input. Please enter BUY or SELL." << std::endl;
}
}
}
// Function to simulate order execution
void execute_trade(TradeSignal trade_signal) {
// Placeholder for trade execution logic
std::cout << "Executing trade: ";
if (trade_signal == TradeSignal::BUY) {
std::cout << "BUY" << std::endl;
}
else {
std::cout << "SELL" << std::endl;
}
// Simulate order execution time
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "Trade execution completed" << std::endl;
}
// Function to simulate the execution loop
void execution_loop() {
while (true) {
// Generate random market data
double market_data = generate_market_data();
// Analyze market data and prompt user for trade decision
TradeSignal trade_decision = analyze_market_data(market_data);
// Execute trade based on user decision
execute_trade(trade_decision);
// Sleep for 10 seconds before next iteration
std::this_thread::sleep_for(std::chrono::seconds(10));
}
}
int main() {
try {
std::cout << "Execution simulation started" << std::endl;
execution_loop();
}
catch (const std::exception& e) {
std::cerr << "An error occurred during execution simulation: " << e.what() << std::endl;
}
catch (...) {
std::cerr << "An unknown error occurred during execution simulation" << std::endl;
}
return 0;
}
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu
// Tips for Getting Started:
// 1. Use the Solution Explorer window to add/manage files
// 2. Use the Team Explorer window to connect to source control
// 3. Use the Output window to see build output and other messages
// 4. Use the Error List window to view errors
// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/quantitative-trading/stock-price-analysis-dashboard/app.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""app.py (stock price analysis dahsboard)"""
import dash
from dash import dcc, html
from dash.dependencies import Input, Output
import yfinance as yf
import plotly.graph_objs as go
# Initialize Dash app
app = dash.Dash(__name__)
# Define app layout
app.layout = html.Div([
html.H1("Real-time Stock Price Analysis Dashboard"),
html.Label("Enter stock symbols (comma-separated):"),
dcc.Input(id="stock-input", type="text", value="AAPL,MSFT,GOOGL"),
html.Button(id="submit-button", n_clicks=0, children="Submit"),
dcc.Graph(id="stock-price-chart")
])
# Callback to update stock price chart
@app.callback(
Output("stock-price-chart", "figure"),
[Input("submit-button", "n_clicks")],
[dash.dependencies.State("stock-input", "value")]
)
def update_stock_price_chart(n_clicks, stock_symbols):
# Split entered symbols and fetch historical stock data for each symbol
symbols = [s.strip() for s in stock_symbols.split(",")]
data = []
for symbol in symbols:
stock_data = yf.download(symbol, start="2022-01-01", end="2022-12-31")
trace = go.Candlestick(
x=stock_data.index,
open=stock_data["Open"],
high=stock_data["High"],
low=stock_data["Low"],
close=stock_data["Close"],
name=symbol
)
data.append(trace)
# Create Plotly figure
layout = {
"title": "Real-time Stock Price Analysis",
"xaxis": {"title": "Date"},
"yaxis": {"title": "Price (USD)"},
"showlegend": True
}
fig = go.Figure(data=data, layout=layout)
return fig
if __name__ == "__main__":
app.run_server(debug=True)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/pension | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/pension/python-draft/pension_and_postretirement_benefits.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""pension_and_postretirement_benefits.py
This script estimates the present value of pension obligations and other postretirement benefits,
including actuarial valuations and assumptions, in compliance with ASC 715 (Compensation—Retirement Benefits)
and ASC 715-60 (Other Postretirement Benefits).
"""
from typing import List
def main() -> None:
"""Driving code"""
# example usage
pension_payments = 50000 * 10 # projected pension benefit payments of $50,000 per year for 10 years
postretirement_benefit_payments = 30000 * 15 # projected postretirement benefit payments of $30,000 per year for 15 years
discount_rate = 0.05 # discount rate
# estimate present value of pension obligations
present_value_pension = present_value_of_pension_obligations(pension_payments, discount_rate)
print("Present Value of Pension Obligations:", present_value_pension)
# estimate present value of postretirement benefits
present_value_postretirement = present_value_of_postretirement_benefits(postretirement_benefit_payments, discount_rate)
print("Present Value of Postretirement Benefits:", present_value_postretirement)
return None
def present_value_of_pension_obligations(pension_payments: List[float], discount_rate: float) -> float:
"""Estimate the present value of pension obligations using the projected benefit payments and discount rate.
Parameters:
pension_payments (List[float]): List of projected benefit payments over the pension period.
discount_rate (float): Discount rate used to calculate the present value.
Returns:
float: Present value of pension obligations.
"""
present_value = sum([payment / ((1 + discount_rate) ** (index + 1)) for index, payment in enumerate(pension_payments)])
return present_value
def present_value_of_postretirement_benefits(benefit_payments: List[float], discount_rate: float) -> float:
"""Estimate the present value of other postretirement benefits using the projected benefit payments and discount rate.
Parameters:
benefit_payments (List[float]): List of projected benefit payments over the postretirement period.
discount_rate (float): Discount rate used to calculate the present value.
Returns:
float: Present value of other postretirement benefits.
"""
present_value = sum([payment / ((1 + discount_rate) ** (index + 1)) for index, payment in enumerate(benefit_payments)])
return present_value
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/segment-reporting | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/segment-reporting/python-draft/segment_reporting.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""segment_reporting.py
This script demonstrates segment reporting by identifying and aggregating operating segments,
calculating segment revenue, profit or loss, and segment assets, in accordance with ASC 280 (Segment Reporting).
"""
from typing import Dict
def main():
"""Driving code and example usage."""
segments = {
"Segment A": OperatingSegment("Segment A", revenue=1000000, expenses=800000, assets=500000),
"Segment B": OperatingSegment("Segment B", revenue=800000, expenses=600000, assets=400000),
"Segment C": OperatingSegment("Segment C", revenue=600000, expenses=400000, assets=300000)
}
# aggregate segment results
aggregated_results = aggregate_segment_results(segments)
print("Segment Reporting Results:")
for item, value in aggregated_results.items():
print(item + ":", value)
return None
class OperatingSegment:
"""
A class representing an operating segment of a business.
"""
def __init__(self, name: str, revenue: float, expenses: float, assets: float) -> None:
"""Initializes an instance of the OperatingSegment class with the provided attributes.
Parameters:
name (str) -- The name of the operating segment.
revenue (float) -- The revenue generated by the operating segment.
expenses (float) -- The expenses incurred by the operating segment.
assets (float) -- The total assets of the operating segment.
"""
self.name = name
self.revenue = revenue
self.expenses = expenses
self.assets = assets
return None
def aggregate_segment_results(segments: Dict[str, OperatingSegment]) -> Dict[str, float]:
"""Aggregate segment results for segment reporting purposes.
Parameters:
segments (Dict[str, OperatingSegment]) -- Dictionary containing operating segments.
Returns:
Dict[str, float] -- Aggregated segment results (total revenue, total expenses, total assets).
"""
total_revenue = sum(segment.revenue for segment in segments.values())
total_expenses = sum(segment.expenses for segment in segments.values())
total_assets = sum(segment.assets for segment in segments.values())
return {"Total Revenue": total_revenue, "Total Expenses": total_expenses, "Total Assets": total_assets}
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/revenue-recognition | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/revenue-recognition/python-draft/revenue_recognition.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""revenue_recognition.py
This script demonstrates revenue recognition from contracts with customers,
applying the principles of ASC 606 (Revenue from Contracts with Customers).
"""
from typing import List
def main() -> None:
"""Driving code"""
# Example usage
prices = [5000, 7000, 3000] # Prices of individual performance obligations
total_price = estimate_transaction_price(prices)
# Allocate transaction price to each performance obligation
allocated_prices = allocate_transaction_price(prices, total_price)
print("Allocated Transaction Prices:", allocated_prices)
return None
def estimate_transaction_price(prices: List[float]) -> float:
"""Estimate the transaction price by summing up the prices of individual performance obligations.
Parameters:
prices (List[float]): List of prices of individual performance obligations.
Returns:
float: Estimated transaction price.
"""
transaction_price = sum(prices)
return transaction_price
def allocate_transaction_price(prices: List[float], total_price: float) -> List[float]:
"""Allocate the transaction price to each performance obligation based on its relative standalone selling price.
Parameters:
prices (List[float]): List of prices of individual performance obligations.
total_price (float): Total transaction price.
Returns:
List[float]: Allocated transaction price for each performance obligation.
"""
allocated_prices = [price / total_price for price in prices]
return allocated_prices
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/business-combinations | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/business-combinations/python-draft/business_combinations.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""business_combinations.py
This script performs purchase price allocation and measures goodwill or bargain purchase gain
as part of business combination accounting under ASC 805 (Business Combinations).
"""
from typing import Dict
def main():
"""main program and entrypoint."""
consideration_transferred = 1000000 # fair value of consideration transferred
fair_values = {
"identifiable_assets": 800000, # fair value of identifiable assets acquired
"liabilities_assumed": 500000, # fair value of liabilities assumed
"non_controlling_interests": 100000 # fair value of non-controlling interests
}
# perform purchase price allocation
allocation_results = perform_purchase_price_allocation(consideration_transferred, fair_values)
print("Identifiable Assets:", allocation_results["identifiable_assets"])
print("Liabilities Assumed:", allocation_results["liabilities_assumed"])
print("Non-Controlling Interests:", allocation_results["non_controlling_interests"])
print("Goodwill or Bargain Purchase Gain:", allocation_results["goodwill_or_bargain_purchase_gain"])
def perform_purchase_price_allocation(consideration_transferred: float, fair_values: Dict[str, float]) -> Dict[str, float]:
"""Perform purchase price allocation.
Keyword arguments:
consideration_transferred (float): Fair value of consideration transferred.
fair_values (Dict[str, float]): Dictionary containing the fair values of identifiable assets acquired,
liabilities assumed, and non-controlling interests.
Returns:
Dict[str, float]: Dictionary containing the allocated values of identifiable assets acquired,
liabilities assumed, and any excess consideration (goodwill) or bargain purchase gain.
Process of PPA:
1. Identifying Assets and Liabilities: Determine all the identifiable assets and liabilities acquired in the acquisition.
These can include tangible assets (such as property, plant, and equipment), intangible assets (such as patents, trademarks,
and customer relationships), and liabilities (such as accounts payable and long-term debt).
2. Determining Fair Values: Assess the fair values of the identifiable assets and liabilities acquired. This may involve various
valuation techniques, such as market-based approaches, income approaches, or cost approaches, depending on the nature of the
assets and liabilities.
3. Allocating Purchase Price: Allocate the purchase price among the identifiable assets and liabilities based on their fair values.
This step requires judgment and may involve negotiation between the buyer and seller.
4. Recording Entries: Record the allocated purchase price on the acquirer's balance sheet. This may involve creating new asset and
liability accounts, as well as recognizing any excess purchase price as goodwill.
5. Amortization and Impairment: Intangible assets acquired through the acquisition are typically subject to amortization over their
useful lives and tested for impairment annually or when there are indications of impairment.
"""
identifiable_assets = fair_values.get("identifiable_assets", 0)
liabilities_assumed = fair_values.get("liabilities_assumed", 0)
non_controlling_interests = fair_values.get("non_controlling_interests", 0)
goodwill_or_bargain_purchase_gain = consideration_transferred - identifiable_assets - liabilities_assumed - non_controlling_interests
allocation_results = {
"identifiable_assets": identifiable_assets,
"liabilities_assumed": liabilities_assumed,
"non_controlling_interests": non_controlling_interests,
"goodwill_or_bargain_purchase_gain": goodwill_or_bargain_purchase_gain
}
return allocation_results
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/impairment-tests | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/impairment-tests/python-draft/impairment_testing.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""impairment_testing.py
This script assesses impairment of assets by comparing their carrying amounts to their recoverable amounts,
as prescribed by standards like ASC 350 (Intangibles—Goodwill and Other) and ASC 360 (Property, Plant, and Equipment).
"""
from typing import Union
def main() -> None:
"""Driving code."""
# example usage
carrying_amount_goodwill = 1000000 # carrying amount of goodwill
recoverable_amount_goodwill = 900000 # recoverable amount of goodwill
carrying_amount_property = 1500000 # carrying amount of property, plant, and equipment
recoverable_amount_property = 1600000 # recoverable amount of property, plant, and equipment
# assess impairment of goodwill
goodwill_impairment = assess_impairment(carrying_amount_goodwill, recoverable_amount_goodwill)
print("Goodwill Impairment Loss:", goodwill_impairment)
# assess impairment of property, plant, and equipment
property_impairment = assess_impairment(carrying_amount_property, recoverable_amount_property)
print("Property Impairment Loss:", property_impairment)
return None
def assess_impairment(carrying_amount: float, recoverable_amount: float) -> Union[float, str]:
"""Assess impairment of an asset by comparing its carrying amount to its recoverable amount.
Parameters:
carrying_amount (float) -- Carrying amount of the asset.
recoverable_amount (float) -- Recoverable amount of the asset.
"""
if carrying_amount > recoverable_amount:
impairment_loss = carrying_amount - recoverable_amount
return impairment_loss
else:
return "No impairment detected."
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/consolidation-and-equity-method-investments | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/consolidation-and-equity-method-investments/python-draft/consolidation_and_equity_method.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""consolidation_and_equity_method.py
This script demonstrates consolidation of financial statements of subsidiaries
and application of the equity method to account for investments in associates and joint ventures,
as outlined in ASC 810 (Consolidation) and ASC 323 (Investments—Equity Method and Joint Ventures).
"""
from typing import List, Dict
def main():
"""Driving code."""
subsidiary_1 = Entity("Subsidiary 1", total_assets=1000000, total_liabilities=500000, net_income=50000)
subsidiary_2 = Entity("Subsidiary 2", total_assets=800000, total_liabilities=300000, net_income=40000)
investee_net_income = 60000 # net income of the investee entity
investor_percentage = 0.5 # percentage of ownership or significant influence
# consolidate financial statements of subsidiaries
consolidated_financials = consolidate_financial_statements([subsidiary_1, subsidiary_2])
print("Consolidated Financial Statements:")
for item, value in consolidated_financials.items():
print(item + ":", value)
# apply equity method for investment in associates
investor_share_of_net_income = apply_equity_method(investee_net_income, investor_percentage)
print("Investor's Share of Net Income (Equity Method):", investor_share_of_net_income)
class Entity:
"""
The class represents a business entity.
"""
def __init__(self, name: str, total_assets: float, total_liabilities: float, net_income: float) -> None:
"""Initializes an instance of the Entity class with the given attributes.
Parameters:
name (str) -- The name of the entity.
total_assets (float) -- The total value of assets owned by the entity.
total_liabilities (float) -- The total value of liabilities owed by the entity.
net_income (float) -- The net income of the entity.
"""
self.name = name
self.total_assets = total_assets
self.total_liabilities = total_liabilities
self.net_income = net_income
return None
def consolidate_financial_statements(entities: List[Entity]) -> Dict[str, float]:
"""Consolidate financial statements of subsidiaries.
Parameters:
entities (List[Entity]) -- List of subsidiary entities.
Returns:
Dict[str, float] -- Consolidated financial statement items (total assets, total liabilities, net income).
"""
total_assets = sum(entity.total_assets for entity in entities)
total_liabilities = sum(entity.total_liabilities for entity in entities)
net_income = sum(entity.net_income for entity in entities)
return {"Total Assets": total_assets, "Total Liabilities": total_liabilities, "Net Income": net_income}
def apply_equity_method(investee_net_income: float, investor_percentage: float) -> float:
"""Apply the equity method to account for investments in associates and joint ventures.
Parameters:
investee_net_income (float) -- Net income of the investee entity.
investor_percentage (float) -- Percentage of ownership or significant influence exerted by the investor.
Returns:
float -- Investor's share of investee net income.
"""
investor_share_of_net_income = investee_net_income * investor_percentage
return investor_share_of_net_income
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/fair-value-measurement | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/fair-value-measurement/python-draft/fair-value-calculation.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""fair_value_calculation.py
This script calculates the fair value of assets and liabilities using various valuation techniques,
including the market approach, income approach, and cost approach, in accordance with ASC 820 (Fair Value Measurement).
"""
from typing import List
def main():
"""Driving code."""
# Example usage
comparable_prices = [1000, 1200, 1100, 1050, 1150]
discounted_cash_flows = [500, 600, 700, 800, 900]
replacement_cost = 2000
depreciation = 0.1
discount_rate = 0.05
market_fair_value = market_approach_valuation(comparable_prices)
income_fair_value = income_approach_valuation(discounted_cash_flows, discount_rate)
cost_fair_value = cost_approach_valuation(replacement_cost, depreciation)
print("Fair Value (Market Approach):", market_fair_value)
print("Fair Value (Income Approach):", income_fair_value)
print("Fair Value (Cost Approach):", cost_fair_value)
def market_approach_valuation(comparable_prices: List[float]) -> float:
"""Calculate fair value using the market approach.
Parameters:
comparable_prices (List[float]): List of comparable prices of similar assets.
Returns:
float: Fair value calculated using the market approach.
"""
fair_value = sum(comparable_prices) / len(comparable_prices)
return fair_value
def income_approach_valuation(discounted_cash_flows: List[float], discount_rate: float) -> float:
"""
Calculate fair value using the income approach (DCF).
Args:
discounted_cash_flows (List[float]): List of discounted cash flows.
discount_rate (float): Discount rate used in the discounted cash flow analysis.
Returns:
float: Fair value calculated using the income approach.
"""
fair_value = sum(discounted_cash_flows) / (1 + discount_rate) ** len(discounted_cash_flows)
return fair_value
def cost_approach_valuation(replacement_cost: float, depreciation: float) -> float:
"""
Calculate fair value using the cost approach.
Args:
replacement_cost (float): Replacement cost of the asset.
depreciation (float): Depreciation rate applied to the replacement cost.
Returns:
float: Fair value calculated using the cost approach.
"""
fair_value = replacement_cost * (1 - depreciation)
return fair_value
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/lease-accounting | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/lease-accounting/python-draft/lease_accounting.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""lease_accounting.py
This script implements lease accounting requirements under ASC 842 (Leases) for lessees and lessors.
"""
from typing import List, Tuple
def main() -> None:
"""Driving code."""
# Example usage
lease_payments = [10000] * 5 # Lease payments of $10,000 per period for 5 periods
discount_rate = 0.05 # Discount rate
initial_direct_costs = 1000 # Initial direct costs related to the lease
lease_incentive = 500 # Lease incentive received
lease_term = 5 # Lease term in periods
# Calculate present value of lease payments
present_value = calculate_present_value_of_lease_payments(lease_payments, discount_rate)
# Recognize lease assets and liabilities
lease_asset, lease_liability = recognize_lease_assets_and_liabilities(present_value, initial_direct_costs, lease_incentive, lease_term, discount_rate)
print("Present Value of Lease Payments:", present_value)
print("Lease Asset:", lease_asset)
print("Lease Liability:", lease_liability)
return None
def calculate_present_value_of_lease_payments(lease_payments: List[float], discount_rate: float) -> float:
"""Calculate the present value of lease payments using the discount rate.
Parameters:
lease_payments (List[float]) -- List of lease payments.
discount_rate (float) -- Discount rate used to calculate present value.
Returns:
float -- Present value of lease payments.
"""
present_value = sum([payment / ((1 + discount_rate) ** (index + 1)) for index, payment in enumerate(lease_payments)])
return present_value
def recognize_lease_assets_and_liabilities(present_value_of_lease_payments: float, initial_direct_costs: float,
lease_incentive: float, lease_term: float, discount_rate: float) -> Tuple[float, float]:
"""Recognize lease assets and liabilities.
Parameters:
present_value_of_lease_payments (float) -- Present value of lease payments.
initial_direct_costs (float) -- Initial direct costs related to the lease.
lease_incentive (float) -- Lease incentive received.
lease_term (float) -- Lease term.
discount_rate (float) -- Discount rate used to calculate present value.
Returns:
Tuple[float, float] -- Lease assets and lease liabilities.
"""
lease_liability = present_value_of_lease_payments + initial_direct_costs - lease_incentive
lease_asset = lease_liability # For simplicity, assuming the lease asset equals the lease liability
return lease_asset, lease_liability
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/financial-instruments | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/financial-instruments/python-draft/financial_instruments_valuation.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
financial_instruments_valuation.py
This script demonstrates valuation of financial instruments such as derivatives, debt securities, and equity securities
under standards like ASC 815 (Derivatives and Hedging), ASC 320 (Investments—Debt and Equity Securities),
and ASC 825 (Financial Instruments).
"""
from typing import List, Tuple
def main():
# Example usage
notional_amount_derivative = 1000000
risk_factor = 50
volatility = 0.2
time_to_maturity = 1
face_value_debt_security = 1000000
market_interest_rate = 0.05
remaining_time_to_maturity_debt_security = 1
current_price_equity_security = 50
number_of_shares_equity_security = 20000
# Calculate fair value of derivative
derivative_value = calculate_derivative_value(notional_amount_derivative, risk_factor, volatility, time_to_maturity)
print("Fair Value of Derivative:", derivative_value)
# Calculate fair value of debt security
debt_security_value = calculate_debt_securities_value(face_value_debt_security, market_interest_rate, remaining_time_to_maturity_debt_security)
print("Fair Value of Debt Security:", debt_security_value)
# Calculate fair value of equity security
equity_security_value = calculate_equity_securities_value(current_price_equity_security, number_of_shares_equity_security)
print("Fair Value of Equity Security:", equity_security_value)
def calculate_derivative_value(notional_amount: float, risk_factor: float, volatility: float, time_to_maturity: float) -> float:
"""
Calculate the fair value of a derivative using the Black-Scholes model.
Args:
notional_amount (float): Notional amount of the derivative.
risk_factor (float): Underlying asset price or rate.
volatility (float): Volatility of the underlying asset.
time_to_maturity (float): Time to maturity of the derivative.
Returns:
float: Fair value of the derivative.
"""
d1 = (risk_factor / (volatility * (time_to_maturity ** 0.5)))
d2 = d1 - volatility * (time_to_maturity ** 0.5)
fair_value = notional_amount * (risk_factor * norm.cdf(d1) - norm.cdf(d2))
return fair_value
def calculate_debt_securities_value(face_value: float, market_interest_rate: float, remaining_time_to_maturity: float) -> float:
"""
Calculate the fair value of debt securities using the present value of future cash flows.
Args:
face_value (float): Face value of the debt security.
market_interest_rate (float): Market interest rate applicable to the debt security.
remaining_time_to_maturity (float): Remaining time to maturity of the debt security.
Returns:
float: Fair value of the debt security.
"""
fair_value = face_value / ((1 + market_interest_rate) ** remaining_time_to_maturity)
return fair_value
def calculate_equity_securities_value(current_price: float, number_of_shares: int) -> float:
"""
Calculate the fair value of equity securities.
Args:
current_price (float): Current market price of the equity security.
number_of_shares (int): Number of shares of the equity security.
Returns:
float: Fair value of the equity security.
"""
fair_value = current_price * number_of_shares
return fair_value
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/earnings-per-share | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/earnings-per-share/python-draft/earnings_per_share.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""earnings_per_share.py
This script calculates basic and diluted earnings per share (EPS) figures based on weighted average shares outstanding
and potentially dilutive securities, following guidance provided in ASC 260 (Earnings Per Share).
"""
def main() -> None:
"""Driving code."""
# Example usage
net_income = 1000000 # net income
average_shares_outstanding = 500000 # weighted average shares outstanding
dilutive_securities = [
DilutiveSecurity(diluted_shares_issued=50000, is_dilutive=True), # convertible preferred stock
DilutiveSecurity(diluted_shares_issued=20000, is_dilutive=True) # stock options
]
# create an instance of EarningsPerShare
eps = EarningsPerShare(net_income, average_shares_outstanding, dilutive_securities)
# calculate basic and diluted EPS
basic_eps = eps.calculate_basic_eps()
diluted_eps = eps.calculate_diluted_eps()
print("Basic EPS:", basic_eps)
print("Diluted EPS:", diluted_eps)
return None
class EarningsPerShare:
"""
Class represents an Earnings per Share entity.
"""
def __init__(self, net_income: float, average_shares_outstanding: float, dilutive_securities: list = None) -> None:
"""Initializes an instance of the class with the provided attributes.
Parameters:
net_income (float) -- The net income of the entity.
average_shares_outstanding (float) -- The average shares outstanding of the entity.
dilutive_securities (list, optional) -- A list of dilutive securities. Defaults to None.
"""
self.net_income = net_income
self.average_shares_outstanding = average_shares_outstanding
self.dilutive_securities = dilutive_securities if dilutive_securities else []
return None
def calculate_basic_eps(self) -> float:
"""Calculate basic earnings per share (EPS).
Returns:
float: Basic EPS.
"""
return self.net_income / self.average_shares_outstanding
def calculate_diluted_eps(self) -> float:
"""Calculate diluted earnings per share (EPS).
Returns:
float: Diluted EPS.
"""
diluted_shares_outstanding = self.average_shares_outstanding
for security in self.dilutive_securities:
if security.is_dilutive:
diluted_shares_outstanding += security.diluted_shares_issued
return self.net_income / diluted_shares_outstanding
class DilutiveSecurity:
"""
A class representing a dilutive security.
"""
def __init__(self, diluted_shares_issued: float, is_dilutive: bool):
"""Initializes an instance of the DilutiveSecurity class with the provided attributes.
Parameters:
diluted_shares_issued (float) -- The number of diluted shares issued.
is_dilutive (bool) -- Indicates whether the security is dilutive or not.
"""
self.diluted_shares_issued = diluted_shares_issued
self.is_dilutive = is_dilutive
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/income_taxes | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/income_taxes/python-draft/income_tax_calculation.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""income_tax_calculation.py
This script calculates income tax provisions and deferred tax assets/liabilities
based on applicable tax rates, tax laws, and temporary differences between book and tax bases
of assets and liabilities, as governed by ASC 740 (Income Taxes).
"""
from typing import Dict
def main() -> None:
"""Driving code."""
# Example usage
income_before_tax = 1000000 # Income before tax
tax_rate = 0.2 # Applicable tax rate
temporary_differences = {
"Depreciation Expense": 50000, # Temporary difference due to accelerated depreciation
"Accrued Expenses": -20000 # Temporary difference due to accrued expenses
}
# Calculate income tax provision
income_tax_provision = calculate_income_tax_provision(income_before_tax, tax_rate)
print("Income Tax Provision:", income_tax_provision)
# Calculate deferred tax assets/liabilities
deferred_tax_assets_liabilities = calculate_deferred_tax_assets_liabilities(temporary_differences, tax_rate)
print("Deferred Tax Assets/Liabilities:", deferred_tax_assets_liabilities)
return None
def calculate_income_tax_provision(income_before_tax: float, tax_rate: float) -> float:
"""Calculate the income tax provision.
Parameters:
income_before_tax (float) -- Income before tax.
tax_rate (float) -- Applicable tax rate.
Returns:
float -- Income tax provision.
"""
income_tax_provision = income_before_tax * tax_rate
return income_tax_provision
def calculate_deferred_tax_assets_liabilities(temporary_differences: Dict[str, float], tax_rate: float) -> Dict[str, float]:
"""Calculate deferred tax assets/liabilities based on temporary differences between book and tax bases.
Parameters:
temporary_differences (Dict[str, float]): Dictionary containing temporary differences between
book and tax bases of assets and liabilities.
tax_rate (float): Applicable tax rate.
Returns:
Dict[str, float]: Dictionary containing deferred tax assets and liabilities.
"""
deferred_tax_assets_liabilities = {}
for item, difference in temporary_differences.items():
deferred_tax_assets_liabilities[item] = difference * tax_rate
return deferred_tax_assets_liabilities
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/stock-based-compensation | repos/exploratory-tech-studio/tech-studio-projects/financial-industry/regulatory-reporting/us-gaap/stock-based-compensation/python-draft/stock_compensation_valuation.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""stock_compensation_valuation.py
This script estimates the fair value of stock options and recognizes compensation expense over the requisite service period,
in accordance with ASC 718 (Compensation—Stock Compensation).
"""
import numpy as np
from scipy.stats import norm
def main() -> None:
"""Driving code"""
# example usage
stock_price = 100 # current market price of the underlying stock
exercise_price = 90 # exercise price of the option
risk_free_rate = 0.05 # risk-free interest rate
volatility = 0.2 # volatility of the underlying stock
time_to_maturity = 1 # time to maturity of the option
service_period = 4 # requisite service period in years
# calculate fair value of the stock option using Black-Scholes model
option_value = calculate_black_scholes_option_value(stock_price, exercise_price, risk_free_rate, volatility, time_to_maturity)
print("Fair Value of Stock Option:", option_value)
# recognize compensation expense over the requisite service period
compensation_expense = recognize_compensation_expense(option_value, service_period)
print("Compensation Expense Recognized:", compensation_expense)
return None
def calculate_black_scholes_option_value(stock_price: float, exercise_price: float, risk_free_rate: float,
volatility: float, time_to_maturity: float) -> float:
"""Calculate the fair value of a stock option using the Black-Scholes option pricing model.
Parameters:
stock_price (float) -- Current market price of the underlying stock.
exercise_price (float) -- Exercise price of the option.
risk_free_rate (float) -- Risk-free interest rate.
volatility (float) -- Volatility of the underlying stock.
time_to_maturity (float) -- Time to maturity of the option.
Returns:
float -- Fair value of the stock option.
"""
d1 = (np.log(stock_price / exercise_price) + (risk_free_rate + 0.5 * volatility ** 2) * time_to_maturity) / (volatility * np.sqrt(time_to_maturity))
d2 = d1 - volatility * np.sqrt(time_to_maturity)
option_value = stock_price * norm.cdf(d1) - exercise_price * np.exp(-risk_free_rate * time_to_maturity) * norm.cdf(d2)
return option_value
def recognize_compensation_expense(option_value: float, service_period: float) -> float:
"""Recognize compensation expense over the requisite service period.
Parameters:
option_value (float) -- Fair value of the stock option.
service_period (float) -- Requisite service period over which the compensation expense is recognized.
Returns:
float -- Compensation expense recognized for the current period.
"""
compensation_expense = option_value / service_period
return compensation_expense
if __name__ == "__main__":
main()
|
0 | repos | repos/zig-alzette/README.md | # zig-alzette
Implementation of the Alzette box and CRAX block cipher in Zig.
## References
* [Alzette: a 64-bit ARX-box](https://eprint.iacr.org/2019/1378.pdf)
|
0 | repos | repos/zig-alzette/build.zig | const std = @import("std");
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const lib = b.addStaticLibrary(.{
.name = "alzette",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
b.installArtifact(lib);
const main_tests = b.addTest(.{
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
const run_main_tests = b.addRunArtifact(main_tests);
const test_step = b.step("test", "Run library tests");
test_step.dependOn(&run_main_tests.step);
}
|
0 | repos/zig-alzette | repos/zig-alzette/src/main.zig | const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const rotr = std.math.rotr;
pub const CraxS = struct {
const N_STEPS: usize = 10;
const RCON = [5]u32{ 0xB7E15162, 0xBF715880, 0x38B4DA56, 0x324E7738, 0xBB1185EB };
/// A secret key
pub const Key = struct {
w: [4]u32,
pub fn init(bytes: [16]u8) Key {
return Key{
.w = [4]u32{
mem.readInt(u32, bytes[0..4], .little),
mem.readInt(u32, bytes[4..8], .little),
mem.readInt(u32, bytes[8..12], .little),
mem.readInt(u32, bytes[12..16], .little),
},
};
}
};
/// Apply the Alzette box
pub inline fn alzette(x: *u32, y: *u32, comptime c: u32) void {
x.* +%= rotr(u32, y.*, 31);
y.* +%= rotr(u32, x.*, 24);
x.* ^= c;
x.* +%= rotr(u32, y.*, 17);
y.* +%= rotr(u32, x.*, 17);
x.* ^= c;
x.* +%= y.*;
y.* +%= rotr(u32, x.*, 31);
x.* ^= c;
x.* +%= rotr(u32, y.*, 24);
y.* +%= rotr(u32, x.*, 16);
x.* ^= c;
}
/// Apply the inverse Alzette box
pub inline fn alzetteInv(x: *u32, y: *u32, comptime c: u32) void {
x.* ^= c;
y.* -%= rotr(u32, x.*, 16);
x.* -%= rotr(u32, y.*, 24);
x.* ^= c;
y.* -%= rotr(u32, x.*, 31);
x.* -%= y.*;
x.* ^= c;
y.* -%= rotr(u32, x.*, 17);
x.* -%= rotr(u32, y.*, 17);
x.* ^= c;
y.* -%= rotr(u32, x.*, 24);
x.* -%= rotr(u32, y.*, 31);
}
fn _encrypt(x: *u32, y: *u32, k: Key) void {
comptime var step: u32 = 0;
inline while (step < N_STEPS) : (step +%= 1) {
x.* ^= step ^ k.w[2 * (step % 2)];
y.* ^= step ^ k.w[2 * (step % 2) + 1];
alzette(x, y, RCON[step % 5]);
}
x.* ^= k.w[0];
y.* ^= k.w[1];
}
fn _decrypt(x: *u32, y: *u32, k: Key) void {
x.* ^= k.w[0];
y.* ^= k.w[1];
comptime var step: u32 = N_STEPS - 1;
inline while (true) : (step -= 1) {
alzetteInv(x, y, RCON[step % 5]);
x.* ^= step ^ k.w[2 * (step % 2)];
y.* ^= step ^ k.w[2 * (step % 2) + 1];
if (step == 0) break;
}
}
/// Encrypt a 64-bit value using a key k
pub fn encrypt64(in: u64, k: Key) u64 {
var x: u32 = @truncate(in);
var y: u32 = @truncate(in >> 32);
_encrypt(&x, &y, k);
return @as(u64, x) | (@as(u64, y) << 32);
}
/// Decrypt a 64-bit value using a key k
pub fn decrypt64(in: u64, k: Key) u64 {
var x: u32 = @truncate(in);
var y: u32 = @truncate(in >> 32);
_decrypt(&x, &y, k);
return @as(u64, x) | (@as(u64, y) << 32);
}
/// Encrypt a 32-bit value using a key k
pub fn encrypt32(in: [2]u32, k: Key) [2]u32 {
var out = in;
_encrypt(&out[0], &out[1], k);
return out;
}
/// Decrypt a 32-bit value using a key k
pub fn decrypt32(in: [2]u32, k: Key) [2]u32 {
var out = in;
_decrypt(&out[0], &out[1], k);
return out;
}
/// Encrypt 8 bytes using a key k
pub fn encrypt(in: [8]u8, k: Key) [8]u8 {
var x = mem.readInt(u32, in[0..4], .little);
var y = mem.readInt(u32, in[4..8], .little);
_encrypt(&x, &y, k);
var out: [8]u8 = undefined;
mem.writeInt(u32, out[0..4], x, .little);
mem.writeInt(u32, out[4..8], y, .little);
return out;
}
/// Decrypt 8 bytes using a key k
pub fn decrypt(in: [8]u8, k: Key) [8]u8 {
var x = mem.readInt(u32, in[0..4], .little);
var y = mem.readInt(u32, in[4..8], .little);
_decrypt(&x, &y, k);
var out: [8]u8 = undefined;
mem.writeInt(u32, out[0..4], x, .little);
mem.writeInt(u32, out[4..8], y, .little);
return out;
}
};
test "CRAX-S test" {
const k = CraxS.Key.init([_]u8{0x42} ** 16);
const in64: u64 = 0x0123456789abcdef;
const e64 = CraxS.encrypt64(in64, k);
const d64 = CraxS.decrypt64(e64, k);
try testing.expectEqual(e64, 0x5bcff61869b506ac);
try testing.expectEqual(d64, in64);
const in32 = [2]u32{ 0x123456, 0xabcdef };
const e32 = CraxS.encrypt32(in32, k);
const d32 = CraxS.decrypt32(e32, k);
try testing.expectEqual(d32, in32);
const m = "12345678".*;
const em = CraxS.encrypt(m, k);
const de = CraxS.decrypt(em, k);
try testing.expectEqual(de, m);
}
|
0 | repos | repos/zig-gorillas/vcpkg.json | {
"name": "zig-gorillas",
"version-string": "1.0.0",
"maintainers": [
"Fabio Arnold <[email protected]>"
],
"description": "A clone of the classic QBasic Gorillas written in the Zig programming language.",
"homepage": "https://fabioarnold.de",
"license": "MIT",
"supports": "windows",
"dependencies": [
"sdl2"
]
} |
0 | repos | repos/zig-gorillas/banana.rc | 1 ICON "banana.ico" |
0 | repos | repos/zig-gorillas/LICENSE.txt | The MIT License (MIT)
Copyright (c) 2021 Fabio Arnold
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. |
0 | repos | repos/zig-gorillas/README.md | # ⚡ Zig Gorillas 🦍
A clone of the classic [QBasic Gorillas](https://www.youtube.com/watch?v=UDc3ZEKl-Wc) written in the [Zig programming language](https://ziglang.org).
Take turns in throwing an exploding banana at each other. Specify angle and velocity of your throw while taking the blowing wind into consideration.
## Download
* [Windows (64 Bit)](https://github.com/fabioarnold/zig-gorillas/releases/download/1.0/zig-gorillas-win64.zip)
## Building from source
### Requirements
* A current master build of the [Zig compiler](https://ziglang.org/download/)
* Only on Windows: [vcpkg package manager](https://github.com/microsoft/vcpkg) to install ...
* The [SDL2 library](https://libsdl.org)
### Build and run
```
$ zig build run
```
## Credits
* [nanovg library](https://github.com/memononen/nanovg) by Mikko Mononen
* [Press Start 2P font](http://www.zone38.net/font/#pressstart) by codeman38
## License
Zig Gorillas is licensed under the MIT License, see [LICENSE.txt](https://github.com/fabioarnold/zig-gorillas/blob/master/LICENSE.txt) for more information. |
0 | repos | repos/zig-gorillas/build.zig | const std = @import("std");
pub fn build(b: *std.build.Builder) !void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "ZigGorillas",
.root_source_file = .{ .path = "src/main.zig" },
.target = target,
.optimize = optimize,
.main_pkg_path = .{ .path = "." },
});
if (exe.target.isWindows()) {
exe.addVcpkgPaths(.dynamic) catch @panic("vcpkg not installed");
if (exe.vcpkg_bin_path) |path| {
const src_path = try std.fs.path.join(b.allocator, &.{ path, "SDL2.dll" });
b.installBinFile(src_path, "SDL2.dll");
}
exe.subsystem = .Windows;
exe.linkSystemLibrary("shell32");
exe.addObjectFile(.{ .path = "banana.o" });
}
exe.addIncludePath(.{ .path = "lib/nanovg/src" });
const c_flags = &.{ "-std=c99", "-D_CRT_SECURE_NO_WARNINGS", "-Ilib/gl2/include" };
exe.addCSourceFile(.{ .file = .{ .path = "src/c/nanovg_gl2_impl.c" }, .flags = c_flags });
exe.linkSystemLibrary("SDL2");
if (exe.target.isDarwin()) {
exe.linkFramework("OpenGL");
} else if (exe.target.isWindows()) {
exe.linkSystemLibrary("opengl32");
} else {
exe.linkSystemLibrary("gl");
}
exe.linkLibC();
b.installArtifact(exe);
const run_cmd = b.addRunArtifact(exe);
run_cmd.step.dependOn(b.getInstallStep());
const run_step = b.step("run", "Run ZigGorillas");
run_step.dependOn(&run_cmd.step);
}
|
0 | repos/zig-gorillas/lib | repos/zig-gorillas/lib/nanovg/premake4.lua |
local action = _ACTION or ""
solution "nanovg"
location ( "build" )
configurations { "Debug", "Release" }
platforms {"native", "x64", "x32"}
project "nanovg"
language "C"
kind "StaticLib"
includedirs { "src" }
files { "src/*.c" }
targetdir("build")
defines { "_CRT_SECURE_NO_WARNINGS" } --,"FONS_USE_FREETYPE" } Uncomment to compile with FreeType support
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gl2"
kind "ConsoleApp"
language "C"
files { "example/example_gl2.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
defines { "NANOVG_GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gl3"
kind "ConsoleApp"
language "C"
files { "example/example_gl3.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
defines { "NANOVG_GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gl2_msaa"
kind "ConsoleApp"
language "C"
defines { "DEMO_MSAA" }
files { "example/example_gl2.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
defines { "NANOVG_GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gl3_msaa"
kind "ConsoleApp"
language "C"
defines { "DEMO_MSAA" }
files { "example/example_gl3.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
defines { "NANOVG_GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_fbo"
kind "ConsoleApp"
language "C"
files { "example/example_fbo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gles2"
kind "ConsoleApp"
language "C"
files { "example/example_gles2.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
project "example_gles3"
kind "ConsoleApp"
language "C"
files { "example/example_gles3.c", "example/demo.c", "example/perf.c" }
includedirs { "src", "example" }
targetdir("build")
links { "nanovg" }
configuration { "linux" }
linkoptions { "`pkg-config --libs glfw3`" }
links { "GL", "GLU", "m", "GLEW" }
configuration { "windows" }
links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32", "kernel32" }
defines { "NANOVG_GLEW", "_CRT_SECURE_NO_WARNINGS" }
configuration { "macosx" }
links { "glfw3" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo", "-framework Carbon" }
configuration "Debug"
defines { "DEBUG" }
flags { "Symbols", "ExtraWarnings"}
configuration "Release"
defines { "NDEBUG" }
flags { "Optimize", "ExtraWarnings"}
|
Subsets and Splits