import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

def main():
    print("Dette programmet løser andregradslikningen ax^2 + bx + c = 0.")
    print("Skriv inn konstantene a, b og c som heltall eller desimaltall.")
    
    # Tar imot koeffisientene fra brukeren
    a = float(input("Skriv inn konstanten a: "))
    b = float(input("Skriv inn konstanten b: "))
    c = float(input("Skriv inn konstanten c: "))

    # Definerer symbolet x
    x = sp.symbols('x')
    
    # Definerer likningen
    eq = sp.Eq(a*x**2 + b*x + c, 0)
    
    # Løser likningen
    løsninger = sp.solve(eq, x)
    
    # Presenter løsningen
    if len(løsninger) == 0:
        print("Likningen har ingen reelle løsninger.")
    elif len(løsninger) == 1:
        print(f"Likningen har én løsning: x = {løsninger[0]}")
    else:
        print(f"Likningen har to løsninger: x1 = {løsninger[0]}, x2 = {løsninger[1]}")
    
    # Plotting
    plot_eq(a, b, c, løsninger)

def plot_eq(a, b, c, løsninger):
    # Definerer symbolet x
    x = sp.symbols('x')
    
    # Lager funksjonen for plotting
    f = a*x**2 + b*x + c
    
    # Konverterer til en funksjon som kan evalueres numerisk
    f_lambdified = sp.lambdify(x, f, 'numpy')
    
    # Genererer x-verdier
    x_vals = np.linspace(-10, 10, 400)
    
    # Beregner y-verdier
    y_vals = f_lambdified(x_vals)
    
    # Lager plottet
    plt.figure(figsize=(10, 6))
    plt.plot(x_vals, y_vals, label=f'{a}x^2 + {b}x + {c}')
    
    # Plotter løsningene
    for løsning in løsninger:
        if sp.im(løsning) == 0:  # Sjekker om løsningen er reell
            plt.plot([løsning.evalf()], [0], 'ro')
            plt.annotate(f'x = {løsning.evalf()}', (løsning.evalf(), 0), textcoords="offset points", xytext=(0,10), ha='center')
    
    # Legger til detaljer i plottet
    plt.axhline(0, color='black',linewidth=0.5)
    plt.axvline(0, color='black',linewidth=0.5)
    plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
    plt.title("Plot av andregradslikningen og dens løsninger")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.legend()
    plt.show()

if __name__ == "__main__":
    main()

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

def solve_first_order_ode():
    t = sp.symbols('t')
    y = sp.Function('y')(t)
    
    ode = sp.Eq(sp.diff(y, t), t*y)
    ySol = sp.dsolve(ode)
    print("Løsning for første ordens differensiallikning:")
    sp.pretty_print(ySol)

    # Initialbetingelse
    cond = sp.Eq(y.subs(t, 0), 2)
    ySol_cond = sp.dsolve(ode, ics={y.subs(t, 0): 2})
    print("Løsning med initialbetingelse y(0) = 2:")
    sp.pretty_print(ySol_cond)

def solve_nonlinear_ode():
    t = sp.symbols('t')
    y = sp.Function('y')(t)
    
    ode = sp.Eq((sp.diff(y, t) + y)**2, 1)
    ySol = sp.dsolve(ode)
    print("Løsning for ikke-lineær differensiallikning:")
    sp.pretty_print(ySol)

    # Initialbetingelse
    cond = sp.Eq(y.subs(t, 0), 0)
    ySol_cond = sp.dsolve(ode, ics={y.subs(t, 0): 0})
    print("Løsning med initialbetingelse y(0) = 0:")
    sp.pretty_print(ySol_cond)

def solve_second_order_ode():
    x = sp.symbols('x')
    y = sp.Function('y')(x)
    Dy = y.diff(x)

    ode = sp.Eq(y.diff(x, 2), sp.cos(2*x) - y)
    cond1 = sp.Eq(y.subs(x, 0), 1)
    cond2 = sp.Eq(Dy.subs(x, 0), 0)
    ySol = sp.dsolve(ode, ics={y.subs(x, 0): 1, Dy.subs(x, 0): 0})
    ySol = sp.simplify(ySol)
    print("Løsning for andre ordens differensiallikning med initialbetingelser:")
    sp.pretty_print(ySol)

def solve_third_order_ode():
    x = sp.symbols('x')
    u = sp.Function('u')(x)
    Du = u.diff(x)
    D2u = u.diff(x, 2)

    ode = sp.Eq(u.diff(x, 3), u)
    cond1 = sp.Eq(u.subs(x, 0), 1)
    cond2 = sp.Eq(Du.subs(x, 0), -1)
    cond3 = sp.Eq(D2u.subs(x, 0), sp.pi)
    uSol = sp.dsolve(ode, ics={u.subs(x, 0): 1, Du.subs(x, 0): -1, D2u.subs(x, 0): sp.pi})
    print("Løsning for tredje ordens differensiallikning med initialbetingelser:")
    sp.pretty_print(uSol)

def main():
    print("Løsning av differensiallikninger med SymPy")
    
    # Første ordens differensiallikning
    solve_first_order_ode()
    
    # Ikke-lineær differensiallikning
    solve_nonlinear_ode()
    
    # Andre ordens differensiallikning med initialbetingelser
    solve_second_order_ode()
    
    # Tredje ordens differensiallikning med initialbetingelser
    solve_third_order_ode()

if __name__ == "__main__":
    main()

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

# SymPy Solutions

def plot_sympy_solution():
    t = sp.symbols('t')
    y = sp.Function('y')(t)
    
    # First order ODE
    ode1 = sp.Eq(sp.diff(y, t), t * y)
    ySol1 = sp.dsolve(ode1, ics={y.subs(t, 0): 2})
    ySol1 = sp.lambdify(t, ySol1.rhs, 'numpy')
    
    t_vals = np.linspace(0, 5, 100)
    y_vals1 = ySol1(t_vals)
    
    plt.figure(figsize=(10, 6))
    plt.plot(t_vals, y_vals1, label="First Order ODE Solution")
    
    # Second order ODE
    x = sp.symbols('x')
    y = sp.Function('y')(x)
    Dy = y.diff(x)
    ode2 = sp.Eq(y.diff(x, 2), sp.cos(2 * x) - y)
    ySol2 = sp.dsolve(ode2, ics={y.subs(x, 0): 1, Dy.subs(x, 0): 0})
    ySol2 = sp.lambdify(x, ySol2.rhs, 'numpy')
    
    x_vals = np.linspace(0, 5, 100)
    y_vals2 = ySol2(x_vals)
    
    plt.plot(x_vals, y_vals2, label="Second Order ODE Solution")
    
    plt.xlabel("t / x")
    plt.ylabel("y(t) / y(x)")
    plt.legend()
    plt.show()

plot_sympy_solution()

import matplotlib.pyplot as plt
import deepxde as dde

def plot_pinn_training(losshistory, train_state):
    # Visualize loss history
    plt.figure(figsize=(10, 6))
    plt.plot(losshistory.steps, losshistory.loss_train, label='Training loss')
    plt.plot(losshistory.steps, losshistory.loss_test, label='Test loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

# Eksempel på hvordan du kan kalle funksjonen etter å ha trent modellen
# plot_pinn_training(losshistory, train_state)

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import deepxde as dde

# 1. Solve Differential Equations using SymPy

def solve_first_order_ode_sympy():
    t = sp.symbols('t')
    y = sp.Function('y')(t)
    ode = sp.Eq(sp.diff(y, t), t * y)
    ySol = sp.dsolve(ode)
    print("SymPy løsning for første ordens differensiallikning:")
    sp.pretty_print(ySol)

    # Initialbetingelse
    cond = sp.Eq(y.subs(t, 0), 2)
    ySol_cond = sp.dsolve(ode, ics={y.subs(t, 0): 2})
    print("SymPy løsning med initialbetingelse y(0) = 2:")
    sp.pretty_print(ySol_cond)

def solve_nonlinear_ode_sympy():
    t = sp.symbols('t')
    y = sp.Function('y')(t)
    ode = sp.Eq((sp.diff(y, t) + y)**2, 1)
    ySol = sp.dsolve(ode)
    print("SymPy løsning for ikke-lineær differensiallikning:")
    sp.pretty_print(ySol)

    # Initialbetingelse
    cond = sp.Eq(y.subs(t, 0), 0)
    ySol_cond = sp.dsolve(ode, ics={y.subs(t, 0): 0})
    print("SymPy løsning med initialbetingelse y(0) = 0:")
    sp.pretty_print(ySol_cond)

def solve_second_order_ode_sympy():
    x = sp.symbols('x')
    y = sp.Function('y')(x)
    Dy = y.diff(x)
    ode = sp.Eq(y.diff(x, 2), sp.cos(2 * x) - y)
    cond1 = sp.Eq(y.subs(x, 0), 1)
    cond2 = sp.Eq(Dy.subs(x, 0), 0)
    ySol = sp.dsolve(ode, ics={y.subs(x, 0): 1, Dy.subs(x, 0): 0})
    ySol = sp.simplify(ySol)
    print("SymPy løsning for andre ordens differensiallikning med initialbetingelser:")
    sp.pretty_print(ySol)

def solve_third_order_ode_sympy():
    x = sp.symbols('x')
    u = sp.Function('u')(x)
    Du = u.diff(x)
    D2u = u.diff(x, 2)
    ode = sp.Eq(u.diff(x, 3), u)
    cond1 = sp.Eq(u.subs(x, 0), 1)
    cond2 = sp.Eq(Du.subs(x, 0), -1)
    cond3 = sp.Eq(D2u.subs(x, 0), sp.pi)
    uSol = sp.dsolve(ode, ics={u.subs(x, 0): 1, Du.subs(x, 0): -1, D2u.subs(x, 0): sp.pi})
    print("SymPy løsning for tredje ordens differensiallikning med initialbetingelser:")
    sp.pretty_print(uSol)

# 2. Solve Differential Equations using DeepXDE (PINNs)

def solve_ode_pinn():
    # Define the ODE system
    def ode_system(t, u):
        du_t = dde.grad.jacobian(u, t)
        return du_t - tf.math.cos(2 * np.pi * t)

    def boundary(t, on_initial):
        return on_initial and np.isclose(t[0], 0)

    # Define geometry and initial condition
    geom = dde.geometry.TimeDomain(0, 2)
    ic = dde.IC(geom, lambda t: 1, boundary)

    # Define problem
    data = dde.data.PDE(geom, ode_system, ic, num_domain=30, num_boundary=2, solution=lambda t: np.sin(2 * np.pi * t) / (2 * np.pi) + 1, num_test=100)

    # Define the neural network
    net = dde.maps.FNN([1] + [32] * 2 + [1], "tanh", "Glorot uniform")
    model = dde.Model(data, net)
    model.compile("adam", lr=0.001)

    # Train the model
    losshistory, train_state = model.train(epochs=6000)
    dde.saveplot(losshistory, train_state, issave=False, isplot=True)

    # Predictions
    test_t = np.linspace(0, 2, 100)
    pred_u = model.predict(test_t).flatten()
    true_u = np.sin(2 * np.pi * test_t) / (2 * np.pi) + 1

    # Plot results
    plt.figure(figsize=(10, 8))
    plt.plot(test_t, true_u, label="True solution")
    plt.plot(test_t, pred_u, '--', label="PINN prediction")
    plt.xlabel("t")
    plt.ylabel("u(t)")
    plt.legend()
    plt.show()

def main():
    print("Løsning av differensiallikninger med SymPy")
    
    # SymPy solutions
    solve_first_order_ode_sympy()
    solve_nonlinear_ode_sympy()
    solve_second_order_ode_sympy()
    solve_third_order_ode_sympy()
    
    print("Løsning av differensiallikninger med PINNs (DeepXDE)")
    
    # PINNs solution
    solve_ode_pinn()

if __name__ == "__main__":
    main()

import numpy as np

def solve_linear_equations():
    # Definer koeffisientmatriser og høyresidevektorer
    A = np.array([[3, -9], [2, 4]])
    b = np.array([-42, 2])
    
    # Løs lineære ligninger
    z = np.linalg.solve(A, b)
    print("Løsning for første sett av lineære ligninger:", z)
    
    M = np.array([[1, -2, -1], [2, 2, -1], [-1, -1, 2]])
    c = np.array([6, 1, 1])
    
    # Løs lineære ligninger
    y = np.linalg.solve(M, c)
    print("Løsning for andre sett av lineære ligninger:", y)

solve_linear_equations()

import numpy as np
from scipy.optimize import fsolve

def solve_nonlinear_equations():
    def myFunction(z):
        x, y, w = z
        F = np.empty(3)
        F[0] = x**2 + y**2 - 20
        F[1] = y - x**2
        F[2] = w + 5 - x * y
        return F

    zGuess = np.array([1, 1, 1])
    z = fsolve(myFunction, zGuess)
    print("Løsning for ikke-lineære ligninger med fsolve:", z)

solve_nonlinear_equations()

from gekko import GEKKO

def solve_nonlinear_equations_gekko():
    m = GEKKO()
    x, y, w = [m.Var(1) for _ in range(3)]
    m.Equations([x**2 + y**2 == 20, y - x**2 == 0, w + 5 - x * y == 0])
    m.solve(disp=False)
    print("Løsning for ikke-lineære ligninger med GEKKO:", x.value, y.value, w.value)

solve_nonlinear_equations_gekko()

import sympy as sp

def solve_symbolic_equations():
    sp.init_printing()
    x, y, z = sp.symbols('x y z')
    c1 = sp.Symbol('c1')
    
    # Definer ligninger
    f = sp.Eq(2 * x**2 + y + z, 1)
    g = sp.Eq(x + 2 * y + z, c1)
    h = sp.Eq(-2 * x + y, -z)
    
    # Løs ligningene symbolsk
    solutions = sp.solve([f, g, h], (x, y, z))
    print("Symbolske løsninger for ligningssystemet:")
    sp.pretty_print(solutions)

solve_symbolic_equations()

import numpy as np
from scipy.optimize import fsolve

def solve_redlich_kwong():
    # Konstantverdier
    TC = 77  # degC
    P = 1.0  # bar
    a = 2.877e8  # cm^6 bar K^0.5 / mol^2
    b = 60.211  # cm^3 / mol
    Rg = 83.144598  # cm^3 bar / K-mol
    TK = TC + 273.15  # K
    Vg = Rg * TK / P  # ideal gas guess
    
    # Definer funksjonen
    def f(V):
        return P - Rg * TK / (V - b) + a / (np.sqrt(TK) * V * (V + b))
    
    # Løs for dampvolum
    V = fsolve(f, Vg)
    print(f'Scipy løsning for dampvolum: {V[0]:0.1f} cm^3/mol')
    
    # Løs for væskevolum
    V = fsolve(f, b * 1.1)
    print(f'Scipy løsning for væskevolum: {V[0]:0.1f} cm^3/mol')

    # Løsning med GEKKO
    from gekko import GEKKO
    m = GEKKO(remote=False)
    V = m.Var(value=Vg, lb=1e4)
    m.Equation(P == Rg * TK / (V - b) - a / (np.sqrt(TK) * V * (V + b)))
    m.options.SOLVER = 1
    m.solve(disp=False)
    print(f'Gekko løsning for dampvolum: {V.value[0]:0.1f} cm^3/mol')
    
    # Oppdater grenser og startverdi
    V.lower = b * 0.5
    V.upper = b * 2
    V.value = b * 1.1
    m.options.SOLVER = 1
    m.solve(disp=False)
    print(f'Gekko løsning for væskevolum: {V.value[0]:0.1f} cm^3/mol')

solve_redlich_kwong()

import numpy as np
import matplotlib.pyplot as plt

# Parametre
T = 5
a = -1 / T
x0 = 1
tstart = 0
tstop = 25
increment = 1

# Generere tidspunkter
t = np.arange(tstart, tstop + 1, increment)

# Løsning av differensialligningen analytisk
x = x0 * np.exp(a * t)

# Plotting av resultatet
plt.plot(t, x)
plt.title('Løsning av differensialligning analytisk')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([0, 25, 0, 1])
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# Parametre
T = 5
a = -1 / T
tstart = 0
tstop = 25
increment = 1
x0 = 1

# Generere tidspunkter
t = np.arange(tstart, tstop + 1, increment)

# Definerer differensialligningen
def mydiff(x, t):
    return a * x

# Løs differensialligningen
x = odeint(mydiff, x0, t)

# Plotting av resultatet
plt.plot(t, x)
plt.title('Løsning av differensialligning numerisk med odeint')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([0, 25, 0, 1])
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# Parametre
T = 5
a = -1 / T
tstart = 0
tstop = 25
increment = 1
x0 = 1

# Generere tidspunkter
t = np.arange(tstart, tstop + 1, increment)

# Definerer differensialligningen med parameter
def mydiff(x, t, a):
    return a * x

# Løs differensialligningen
x = odeint(mydiff, x0, t, args=(a,))

# Plotting av resultatet
plt.plot(t, x)
plt.title('Løsning av differensialligning med parameterpassing')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([0, 25, 0, 1])
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Modellparametre
T = 5
a = -1 / T

# Simuleringsparametre
Ts = 0.01
Tstop = 25
N = int(Tstop / Ts)  # Simuleringslengde
x = np.zeros(N + 1)  # Initialisering av x-vektoren
x[0] = 1  # Initialbetingelse

# Simulering
for k in range(N):
    x[k + 1] = (1 + a * Ts) * x[k]

# Generere tidspunkter
t = np.arange(0, Tstop + Ts, Ts)  # Lage tidsserie

# Plotting av simuleringsresultatet
plt.plot(t, x)
plt.title('Simulering av differensialligning med diskretisering')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([0, 25, 0, 1])
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# Initialisering
tstart = 0
tstop = 1
increment = 0.01
x0 = 100

# Generere tidspunkter
t = np.arange(tstart, tstop + increment, increment)

# Funksjon som returnerer dx/dt
def bacteriadiff(x, t):
    b = 1
    p = 0.5
    return b * x - p * x**2

# Løs differensialligningen
x = odeint(bacteriadiff, x0, t)

# Plotting av resultatet
plt.plot(t, x)
plt.title('Bakteriesimulering')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([0, 1, 0, 100])
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# Initialisering
tstart = -1
tstop = 1
increment = 0.1
x0 = [1, 1]

# Generere tidspunkter
t = np.arange(tstart, tstop + increment, increment)

# Funksjon som returnerer dx/dt for systemet
def mydiff(x, t):
    dx1dt = -x[1]
    dx2dt = x[0]
    return [dx1dt, dx2dt]

# Løs differensialligningen
x = odeint(mydiff, x0, t)

# Hente ut løsninger
x1 = x[:, 0]
x2 = x[:, 1]

# Plotting av resultatene
plt.plot(t, x1, label='x1')
plt.plot(t, x2, label='x2')
plt.title('Simulering med to variabler')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.grid()
plt.axis([-1, 1, -1.5, 1.5])
plt.legend()
plt.show()

import math
import matplotlib.pyplot as plt
import numpy as np
import sympy as sp

def solve_quadratic():
    print("Velkommen! Dette programmet løser andregradslikninger og forklarer prosessen.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")
    
    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))
    
    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")
    
    # Definerer symbolet x
    x = sp.Symbol('x')
    
    # Lager likningen med SymPy
    equation = sp.Eq(a*x**2 + b*x + c, 0)
    print(f"Ligningen som skal løses: {equation}")
    
    # Løser likningen
    solutions = sp.solveset(equation, x, domain=sp.S.Reals)
    print(f"Løsningene for ligningen er: {solutions}")

    # Håndtering av spesielle tilfeller
    if c == 0:
        x1, x2 = solve_without_constant_term(a, b)
    elif b == 0:
        x1, x2 = solve_without_linear_term(a, c)
    else:
        x1, x2 = solve_general_case(a, b, c)

    # Plotting av funksjonen
    plot_function(a, b, c, solutions)

def solve_without_constant_term(a, b):
    print("\nSpesielt tilfelle: Konstantleddet c er null.")
    print("Likningen kan skrives som ax^2 + bx = 0.")
    print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
    print("Ifølge nullregel må enten x = 0 eller ax + b = 0.")
    x1 = 0
    x2 = -b / a
    print(f"Løsningene er: x = {x1} og x = {x2}.")
    print("Forklaring: Ved å faktorisere ut x får vi to løsninger: x = 0 og x = -b/a.")
    return x1, x2

def solve_without_linear_term(a, c):
    print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
    print("Likningen kan skrives som ax^2 + c = 0.")
    print("Vi flytter c til høyre side og får: ax^2 = -c.")
    if -c / a < 0:
        print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
        return None, None
    else:
        x1 = math.sqrt(-c / a)
        x2 = -math.sqrt(-c / a)
        print(f"Løsningene er: x = {x1} og x = {x2}.")
        print("Forklaring: Vi isolerer x^2 på venstre side og tar kvadratroten av begge sider.")
        return x1, x2

def solve_general_case(a, b, c):
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er positiv og gir to reelle røtter.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er null og gir én dobbel rot.")
        return x, x
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er negativ og gir komplekse røtter.")
        return None, None

    return x1, x2

def plot_function(a, b, c, solutions):
    x_vals = np.linspace(-10, 10, 400)
    y_vals = a*x_vals**2 + b*x_vals + c
    
    plt.figure(figsize=(8, 6))
    plt.plot(x_vals, y_vals, label=f'{a}x^2 + {b}x + {c} = 0')
    
    for sol in solutions:
        if sol.is_real:
            plt.plot(float(sol), 0, 'ro') # Markerer reelle løsninger
            plt.annotate(f'x = {sol}', xy=(float(sol), 0), xytext=(float(sol), 5), textcoords='offset points')
    
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
    plt.title("Grafisk løsning av andregradslikningen")
    plt.legend()
    plt.show()

# Kjøring av skriptet
solve_quadratic()

import sympy as sp
import matplotlib.pyplot as plt
import numpy as np

def input_ligninger():
    antall_ligninger = int(input("Skriv inn antall ligninger i systemet: "))
    variabler = input("Skriv inn variablene (skilt med mellomrom): ").split()
    ligninger = []

    for i in range(antall_ligninger):
        ligning = input(f"Skriv inn ligning {i + 1}: ")
        ligninger.append(sp.sympify(ligning))

    return ligninger, variabler

def solve_and_plot_linear(ligninger, variabler):
    løsninger = sp.linsolve(ligninger, variabler)
    løsninger = list(løsninger)
    
    if not løsninger:
        print("Ingen løsninger for ligningssettet.")
        return
    
    løsning = løsninger[0]
    løsning_dict = dict(zip(variabler, løsning))
    
    print("Løsningene er:")
    for var in variabler:
        print(f"{var} = {løsning_dict[sp.Symbol(var)]}")
    
    if len(variabler) == 2:
        x = sp.Symbol(variabler[0])
        y_løsninger = [sp.solve(ligning, variabler[1])[0] for ligning in ligninger]

        x_vals = np.linspace(-10, 10, 400)
        plt.figure(figsize=(8, 6))

        for y_løsning in y_løsninger:
            y_func = sp.lambdify(x, y_løsning, 'numpy')
            y_vals = y_func(x_vals)
            plt.plot(x_vals, y_vals, label=str(y_løsning))

        plt.axhline(0, color='black', linewidth=0.5)
        plt.axvline(0, color='black', linewidth=0.5)
        plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
        plt.legend()
        plt.show()

def solve_and_plot_nonlinear(ligninger, variabler):
    løsninger = sp.nonlinsolve(ligninger, variabler)
    løsninger = list(løsninger)
    
    if not løsninger:
        print("Ingen løsninger for ligningssettet.")
        return
    
    print("Løsningene er:")
    for løsning in løsninger:
        løsning_dict = dict(zip(variabler, løsning))
        for var in variabler:
            print(f"{var} = {løsning_dict[sp.Symbol(var)]}")
    
    if len(variabler) == 2:
        x, y = sp.symbols(variabler)
        y_løsninger = [sp.solve(ligning, y)[0] for ligning in ligninger]

        x_vals = np.linspace(-10, 10, 400)
        plt.figure(figsize=(8, 6))

        for y_løsning in y_løsninger:
            y_func = sp.lambdify(x, y_løsning, 'numpy')
            y_vals = y_func(x_vals)
            plt.plot(x_vals, y_vals, label=str(y_løsning))

        plt.axhline(0, color='black', linewidth=0.5)
        plt.axvline(0, color='black', linewidth=0.5)
        plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
        plt.legend()
        plt.show()

def main():
    print("Velkommen! Dette programmet løser ligningssett.")
    ligninger, variabler = input_ligninger()
    
    if all([ligning.is_linear for ligning in ligninger]):
        print("Løser lineært ligningssett...")
        solve_and_plot_linear(ligninger, variabler)
    else:
        print("Løser ikke-lineært ligningssett...")
        solve_and_plot_nonlinear(ligninger, variabler)

if __name__ == "__main__":
    main()

import sympy as sp
import matplotlib.pyplot as plt
import numpy as np

def input_ligninger():
    antall_ligninger = int(input("Skriv inn antall ligninger i systemet: "))
    variabler = input("Skriv inn variablene (skilt med mellomrom): ").split()
    ligninger = []

    for i in range(antall_ligninger):
        ligning = input(f"Skriv inn ligning {i + 1}: ")
        ligninger.append(sp.sympify(ligning))

    return ligninger, variabler

def solve_and_plot_linear(ligninger, variabler):
    løsninger = sp.linsolve(ligninger, variabler)
    løsninger = list(løsninger)
    
    if not løsninger:
        print("Ingen løsninger for ligningssettet.")
        return
    
    løsning = løsninger[0]
    løsning_dict = dict(zip(variabler, løsning))
    
    print("Løsningene er:")
    for var in variabler:
        print(f"{var} = {løsning_dict[sp.Symbol(var)]}")
    
    if len(variabler) == 2:
        x = sp.Symbol(variabler[0])
        y_løsninger = [sp.solve(ligning, variabler[1])[0] for ligning in ligninger]

        x_vals = np.linspace(-10, 10, 400)
        plt.figure(figsize=(8, 6))

        for y_løsning in y_løsninger:
            y_func = sp.lambdify(x, y_løsning, 'numpy')
            y_vals = y_func(x_vals)
            plt.plot(x_vals, y_vals, label=str(y_løsning))

        plt.axhline(0, color='black', linewidth=0.5)
        plt.axvline(0, color='black', linewidth=0.5)
        plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
        plt.legend()
        plt.show()

def solve_and_plot_nonlinear(ligninger, variabler):
    løsninger = sp.nonlinsolve(ligninger, variabler)
    løsninger = list(løsninger)
    
    if not løsninger:
        print("Ingen løsninger for ligningssettet.")
        return
    
    print("Løsningene er:")
    for løsning in løsninger:
        løsning_dict = dict(zip(variabler, løsning))
        for var in variabler:
            print(f"{var} = {løsning_dict[sp.Symbol(var)]}")
    
    if len(variabler) == 2:
        x, y = sp.symbols(variabler)
        y_løsninger = [sp.solve(ligning, y)[0] for ligning in ligninger]

        x_vals = np.linspace(-10, 10, 400)
        plt.figure(figsize=(8, 6))

        for y_løsning in y_løsninger:
            y_func = sp.lambdify(x, y_løsning, 'numpy')
            y_vals = y_func(x_vals)
            plt.plot(x_vals, y_vals, label=str(y_løsning))

        plt.axhline(0, color='black', linewidth=0.5)
        plt.axvline(0, color='black', linewidth=0.5)
        plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
        plt.legend()
        plt.show()

def input_ulikheter():
    antall_ulikheter = int(input("Skriv inn antall ulikheter i systemet: "))
    variabler = input("Skriv inn variablene (skilt med mellomrom): ").split()
    ulikheter = []

    for i in range(antall_ulikheter):
        ulikhet = input(f"Skriv inn ulikhet {i + 1}: ")
        ulikheter.append(sp.sympify(ulikhet))

    return ulikheter, variabler

def solve_and_plot_inequalities(ulikheter, variabler):
    gyldigOmråde = sp.And(*ulikheter)
    løsninger = sp.solveset(gyldigOmråde, variabler, domain=sp.Reals)
    
    print("Løsningene er:")
    print(løsninger)
    
    if len(variabler) == 2:
        x, y = sp.symbols(variabler)
        plt.figure(figsize=(8, 6))
        sp.plot_implicit(gyldigOmråde, (x, -10, 10), (y, -10, 10), show=True)

def main():
    print("Velkommen! Dette programmet løser ligningssett og ulikheter.")
    valg = input("Vil du løse ligningssett (1) eller ulikheter (2)? ")

    if valg == '1':
        ligninger, variabler = input_ligninger()
        if all([ligning.is_linear for ligning in ligninger]):
            print("Løser lineært ligningssett...")
            solve_and_plot_linear(ligninger, variabler)
        else:
            print("Løser ikke-lineært ligningssett...")
            solve_and_plot_nonlinear(ligninger, variabler)
    elif valg == '2':
        ulikheter, variabler = input_ulikheter()
        solve_and_plot_inequalities(ulikheter, variabler)
    else:
        print("Ugyldig valg. Vennligst prøv igjen.")

if __name__ == "__main__":
    main()

import math
import matplotlib.pyplot as plt
import numpy as np

def solve_quadratic():
    print("Velkommen! Dette programmet løser andregradslikninger og forklarer prosessen.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")
    
    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))

    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")

    # Håndtering av spesielle tilfeller
    if c == 0:
        x1, x2 = solve_without_constant_term(a, b)
    elif b == 0:
        x1, x2 = solve_without_linear_term(a, c)
    else:
        x1, x2 = solve_general_case(a, b, c)

    # Plotting av funksjonen
    plot_function(a, b, c, x1, x2)

def solve_without_constant_term(a, b):
    print("\nSpesielt tilfelle: Konstantleddet c er null.")
    print("Likningen kan skrives som ax^2 + bx = 0.")
    print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
    print("Ifølge nullregel må enten x = 0 eller ax + b = 0.")
    x1 = 0
    x2 = -b / a
    print(f"Løsningene er: x = {x1} og x = {x2}.")
    print("Forklaring: Ved å faktorisere ut x får vi to løsninger: x = 0 og x = -b/a.")
    return x1, x2

def solve_without_linear_term(a, c):
    print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
    print("Likningen kan skrives som ax^2 + c = 0.")
    print("Vi flytter c til høyre side og får: ax^2 = -c.")
    if -c / a < 0:
        print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
        return None, None
    else:
        x1 = math.sqrt(-c / a)
        x2 = -math.sqrt(-c / a)
        print(f"Løsningene er: x = {x1} og x = {x2}.")
        print("Forklaring: Vi isolerer x^2 på venstre side og tar kvadratroten av begge sider.")
        return x1, x2

def solve_general_case(a, b, c):
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er positiv og gir to reelle røtter.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er null og gir én dobbel rot.")
        return x, x
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er negativ og gir komplekse røtter.")
        return None, None

    return x1, x2

def plot_function(a, b, c, x1, x2):
    x = np.linspace(-10, 10, 400)
    y = a*x**2 + b*x + c
    
    plt.figure(figsize=(8, 6))
    plt.plot(x, y, label=f'{a}x^2 + {b}x + {c} = 0')
    
    if x1 is not None and x2 is not None:
        plt.plot(x1, 0, 'ro') # Mark x1
        plt.plot(x2, 0, 'ro') # Mark x2
        plt.annotate(f'x1 = {x1}', xy=(x1, 0), xytext=(x1, 5), textcoords='offset points')
        plt.annotate(f'x2 = {x2}', xy=(x2, 0), xytext=(x2, -15), textcoords='offset points')
    
    plt.axhline(0, color='black',linewidth=0.5)
    plt.axvline(0, color='black',linewidth=0.5)
    plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
    plt.title("Grafisk løsning av andregradslikningen")
    plt.legend()
    plt.show()

# Kjøring av skriptet
solve_quadratic()

import math

def solve_quadratic():
    print("Velkommen! Dette programmet løser andregradslikninger og forklarer prosessen.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")
    
    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))

    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")

    # Håndtering av spesielle tilfeller
    if c == 0:
        solve_without_constant_term(a, b)
    elif b == 0:
        solve_without_linear_term(a, c)
    else:
        solve_general_case(a, b, c)

def solve_without_constant_term(a, b):
    print("\nSpesielt tilfelle: Konstantleddet c er null.")
    print("Likningen kan skrives som ax^2 + bx = 0.")
    print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
    print("Ifølge nullregel må enten x = 0 eller ax + b = 0.")
    x1 = 0
    x2 = -b / a
    print(f"Løsningene er: x = {x1} og x = {x2}.")
    print("Forklaring: Ved å faktorisere ut x får vi to løsninger: x = 0 og x = -b/a.")

def solve_without_linear_term(a, c):
    print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
    print("Likningen kan skrives som ax^2 + c = 0.")
    print("Vi flytter c til høyre side og får: ax^2 = -c.")
    if -c / a < 0:
        print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
    else:
        x1 = math.sqrt(-c / a)
        x2 = -math.sqrt(-c / a)
        print(f"Løsningene er: x = {x1} og x = {x2}.")
        print("Forklaring: Vi isolerer x^2 på venstre side og tar kvadratroten av begge sider.")

def solve_general_case(a, b, c):
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er positiv og gir to reelle røtter.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er null og gir én dobbel rot.")
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")
        print("Forklaring: Vi har brukt ABC-formelen, hvor diskriminanten er negativ og gir komplekse røtter.")

# Kjøring av skriptet
solve_quadratic()

import math

def quadratic_solver():
    print("Dette programmet løser andregradslikningen ax^2 + bx + c = 0.")
    print("Skriv inn verdiene for konstantene a, b og c for likningen du vil løse.")

    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))

    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")

    # Håndtering av spesielle tilfeller
    if c == 0:
        solve_without_constant_term(a, b)
    elif b == 0:
        solve_without_linear_term(a, c)
    else:
        solve_general_case(a, b, c)

def solve_without_constant_term(a, b):
    print("\nSpesielt tilfelle: Konstantleddet c er null.")
    x1 = 0
    x2 = -b / a
    print(f"Løsningene er: x = {x1} og x = {x2}.")
    print("Forklaring: Vi har faktorisert likningen som x(ax + b) = 0, som gir løsningene x = 0 og x = -b/a.")

def solve_without_linear_term(a, c):
    print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
    if -c / a < 0:
        print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
    else:
        x1 = math.sqrt(-c / a)
        x2 = -math.sqrt(-c / a)
        print(f"Løsningene er: x = {x1} og x = {x2}.")
        print("Forklaring: Vi har isolert x^2 på venstre side og tatt kvadratroten av begge sider.")

def solve_general_case(a, b, c):
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
        print("Forklaring: Vi har brukt abc-formelen, hvor diskriminanten er positiv og gir to reelle røtter.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
        print("Forklaring: Vi har brukt abc-formelen, hvor diskriminanten er null og gir én dobbel rot.")
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")
        print("Forklaring: Vi har brukt abc-formelen, hvor diskriminanten er negativ og gir komplekse røtter.")

# Kjøring av skriptet
quadratic_solver()

import math

def quadratic_solver():
    print("Velkommen! Dette programmet løser andregradslikninger.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")

    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))

    # Håndtering av spesielle tilfeller
    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")

    # Beregning av diskriminanten
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")

    # Håndtering av tilfeller der b eller c er 0
    if c == 0:
        print("\nSpesielt tilfelle: Konstantleddet c er null.")
        x1 = 0
        x2 = -b / a
        print(f"Løsningene er: x = {x1} og x = {x2}.")
    elif b == 0:
        print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
        if -c / a < 0:
            print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            print(f"Løsningene er: x = {x1} og x = {x2}.")

# Kjøring av skriptet
quadratic_solver()

import math

def quadratic_solver():
    print("Velkommen! Dette programmet løser andregradslikninger.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")
    
    # Input fra brukeren
    a = float(input("Skriv inn konstanten a (koeffisienten for x^2): "))
    b = float(input("Skriv inn konstanten b (koeffisienten for x): "))
    c = float(input("Skriv inn konstanten c (konstantleddet): "))

    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print(f"\nLøsning av likningen {a}x^2 + {b}x + {c} = 0")

    # Håndtering av spesielle tilfeller
    if c == 0:
        solve_without_constant_term(a, b)
    elif b == 0:
        solve_without_linear_term(a, c)
    else:
        solve_general_case(a, b, c)

def solve_without_constant_term(a, b):
    print("\nSpesielt tilfelle: Konstantleddet c er null.")
    x1 = 0
    x2 = -b / a
    print(f"Løsningene er: x = {x1} og x = {x2}.")

def solve_without_linear_term(a, c):
    print("\nSpesielt tilfelle: Førstegradsleddet b er null.")
    if -c / a < 0:
        print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
    else:
        x1 = math.sqrt(-c / a)
        x2 = -math.sqrt(-c / a)
        print(f"Løsningene er: x = {x1} og x = {x2}.")

def solve_general_case(a, b, c):
    discriminant = b**2 - 4*a*c
    print(f"Diskriminanten er: {discriminant}")

    if discriminant > 0:
        print("\nDiskriminanten er positiv. Likningen har to reelle løsninger.")
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Løsningene er: x1 = {x1} og x2 = {x2}.")
    elif discriminant == 0:
        print("\nDiskriminanten er null. Likningen har én reell løsning.")
        x = -b / (2*a)
        print(f"Løsningen er: x = {x}.")
    else:
        print("\nDiskriminanten er negativ. Likningen har ingen reelle løsninger.")
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-discriminant) / (2*a)
        print(f"De komplekse løsningene er: x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")

# Kjøring av skriptet
quadratic_solver()

import math

def quadratic_solver():
    print("Velkommen! Dette programmet hjelper deg med å løse andregradslikninger.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")

    # Input fra brukeren
    a = float(input("Hva er verdien for a (koeffisienten for x^2)? "))
    b = float(input("Hva er verdien for b (koeffisienten for x)? "))
    c = float(input("Hva er verdien for c (konstantleddet)? "))

    # Håndtering av spesielle tilfeller
    if a == 0:
        print("Dette er ikke en andregradslikning, da koeffisienten for x^2 er null.")
        return

    print("\nAnalyse av likningen:")
    if c == 0:
        print("\nLøsning når konstantleddet (c) mangler:")
        print("Likningen kan skrives som ax^2 + bx = 0.")
        print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
        print("Ifølge nullregelen må enten x = 0 eller ax + b = 0.")
        x1 = 0
        x2 = -b / a
        print(f"Løsningene er: x = {x1} og x = {x2}.")
        return

    elif b == 0:
        print("\nLøsning når førstegradsleddet (b) mangler:")
        print("Likningen kan skrives som ax^2 + c = 0.")
        print("Vi flytter c til høyre side og får: ax^2 = -c.")
        if -c / a < 0:
            print("Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall).")
            return
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            print(f"Løsningene er: x = {x1} og x = {x2}.")
            return

    else:
        # Beregning av diskriminanten
        discriminant = b**2 - 4*a*c
        if discriminant > 0:
            print("\nLøsning ved bruk av abc-formelen:")
            x1 = (-b + math.sqrt(discriminant)) / (2*a)
            x2 = (-b - math.sqrt(discriminant)) / (2*a)
            print(f"Løsningene er: x = {x1} og x = {x2}.")
            return

        elif discriminant == 0:
            print("\nLøsning når diskriminanten er null:")
            x = -b / (2*a)
            print(f"Løsningen er: x = {x}.")
            return

        else:
            print("\nIngen reell løsning (diskriminanten er negativ).")
            print("For å få en kompleks løsning, bruk komplekse tall:")
            real_part = -b / (2*a)
            imaginary_part = math.sqrt(-discriminant) / (2*a)
            print(f"De komplekse løsningene er: x = {real_part} + {imaginary_part}i og x = {real_part} - {imaginary_part}i.")
            return

# Kjøring av skriptet
quadratic_solver()

import math

def solve_quadratic():
    # Introduksjon og input-spørsmål
    print("Velkommen! Dette skriptet hjelper deg med å løse andregradslikninger uten bruk av abc-formelen.")
    print("En andregradslikning har formen ax^2 + bx + c = 0.")
    print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")

    # Input fra brukeren
    a = float(input("Hva er verdien for a (koeffisienten for x^2)? "))
    b = float(input("Hva er verdien for b (koeffisienten for x)? "))
    c = float(input("Hva er verdien for c (konstantleddet)? "))

    # Ingen konstantledd (c = 0)
    if c == 0:
        print("\nLøsning når konstantleddet (c) mangler:")
        print("Likningen kan skrives som ax^2 + bx = 0.")
        print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
        print("Ifølge nullregelen må enten x = 0 eller ax + b = 0.")
        x1 = 0
        x2 = -b / a
        return f"Løsningene er: x = {x1} og x = {x2}."
    
    # Ingen førstegradsledd (b = 0)
    elif b == 0:
        print("\nLøsning når førstegradsleddet (b) mangler:")
        print("Likningen kan skrives som ax^2 + c = 0.")
        print("Vi flytter c til høyre side og får: ax^2 = -c.")
        if -c / a < 0:
            return "Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall)."
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            return f"Løsningene er: x = {x1} og x = {x2}."
    
    # Faktorisering og fullstendige kvadrater
    else:
        print("\nForsøk på å løse ved faktorisering og fullstendige kvadrater:")
        
        # Fullstendige kvadrater
        if (b**2 - 4*a*c) >= 0:
            print("Løsning ved fullstendige kvadrater:")
            h = b / (2*a)
            k = c / a - (h**2)
            if k >= 0:
                x1 = -h + math.sqrt(k)
                x2 = -h - math.sqrt(k)
                return f"Løsningene er: x = {x1} og x = {x2}."
            else:
                print("Ingen reell løsning med fullstendige kvadrater.")
        
        # Faktorisering (eksempel med stirremetoden)
        print("Forsøk på å løse ved faktorisering (stirremetoden):")
        for i in range(int(-c/a) - 1, int(c/a) + 1):
            if i != 0 and (c / i) + i == b:
                x1 = i
                x2 = -c / i
                return f"Løsningene er: x = {x1} og x = {x2}."
        
        return "Kunne ikke løse ved faktorisering eller fullstendige kvadrater."

# Kjøring av skriptet
print(solve_quadratic())

import math

def solve_quadratic(a, b, c):
    if c == 0:
        # Løsning når konstantleddet mangler
        print("Løsning når konstantleddet mangler:")
        x1 = 0
        x2 = -b / a
        return x1, x2
    elif b == 0:
        # Løsning når førstegradsleddet mangler
        print("Løsning når førstegradsleddet mangler:")
        if -c / a < 0:
            return "Ingen reell løsning"
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            return x1, x2
    else:
        # Løsning med ABC-formelen
        print("Løsning med ABC-formelen:")
        discriminant = b**2 - 4*a*c
        if discriminant > 0:
            x1 = (-b + math.sqrt(discriminant)) / (2*a)
            x2 = (-b - math.sqrt(discriminant)) / (2*a)
            return x1, x2
        elif discriminant == 0:
            x1 = -b / (2*a)
            return x1,
        else:
            return "Ingen reell løsning"

# Input-spørsmål
print("For å løse en andregradslikning, vennligst gi verdiene for a, b, og c.")
a = float(input("Hva er verdien for a? "))
b = float(input("Hva er verdien for b? "))
c = float(input("Hva er verdien for c? "))

# Løsning
løsninger = solve_quadratic(a, b, c)
print("Løsningene er:", løsninger)

import math

def solve_quadratic(a, b, c):
    # Forklaring og prosess for løsning av andregradslikninger
    print("\nForklaring:")
    print("En andregradslikning er en likning som kan skrives på formen ax^2 + bx + c = 0.")
    print("Her er a, b og c koeffisientene. Løsningene på likningen er verdiene av x som gjør at likningen blir sann.")
    
    if c == 0:
        # Løsning når konstantleddet mangler
        print("\nLøsning når konstantleddet (c) mangler:")
        print("Likningen kan skrives som ax^2 + bx = 0.")
        print("Vi faktoriserer ut x fra begge leddene: x(ax + b) = 0.")
        print("Ifølge nullregel må enten x = 0 eller ax + b = 0.")
        x1 = 0
        x2 = -b / a
        return f"x = {x1} eller x = {x2}"
    elif b == 0:
        # Løsning når førstegradsleddet mangler
        print("\nLøsning når førstegradsleddet (b) mangler:")
        print("Likningen kan skrives som ax^2 + c = 0.")
        print("Vi flytter c til høyre side og får: ax^2 = -c.")
        if -c / a < 0:
            return "Ingen reell løsning (vi kan ikke ta kvadratroten av et negativt tall)."
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            return f"x = {x1} eller x = {x2}"
    else:
        # Løsning med ABC-formelen
        print("\nLøsning med ABC-formelen:")
        print("En generell andregradslikning kan skrives som ax^2 + bx + c = 0.")
        print("For å løse denne bruker vi ABC-formelen: x = (-b ± √(b^2 - 4ac)) / 2a.")
        print("Discriminanten Δ = b^2 - 4ac bestemmer antall løsninger:")
        print("Hvis Δ > 0, har vi to reelle løsninger.")
        print("Hvis Δ = 0, har vi én reell løsning.")
        print("Hvis Δ < 0, har vi ingen reelle løsninger.")
        
        discriminant = b**2 - 4*a*c
        if discriminant > 0:
            x1 = (-b + math.sqrt(discriminant)) / (2*a)
            x2 = (-b - math.sqrt(discriminant)) / (2*a)
            return f"x = {x1} eller x = {x2} (to reelle løsninger)"
        elif discriminant == 0:
            x1 = -b / (2*a)
            return f"x = {x1} (én reell løsning)"
        else:
            return "Ingen reell løsning (discriminanten er negativ)."

# Introduksjon og input-spørsmål
print("Velkommen! Dette skriptet løser andregradslikninger og forklarer prosessen.")
print("En andregradslikning har formen ax^2 + bx + c = 0.")
print("Vennligst gi verdiene for a, b og c for likningen du vil løse.")

# Input fra brukeren
a = float(input("Hva er verdien for a (koeffisienten for x^2)? "))
b = float(input("Hva er verdien for b (koeffisienten for x)? "))
c = float(input("Hva er verdien for c (konstantleddet)? "))

# Løsning
resultat = solve_quadratic(a, b, c)
print("\nLøsningene er:", resultat)

# Eksempel og detaljert prosess (bare for en mer detaljert forklaring)
print("\nEksempel på hvordan skriptet fungerer:")
print("La oss si at vi har likningen 2x^2 - 4x - 6 = 0.")
print("a = 2, b = -4, c = -6.")
print("Bruker vi ABC-formelen, finner vi først discriminanten Δ = (-4)^2 - 4*2*(-6) = 16 + 48 = 64.")
print("Siden Δ > 0, har vi to reelle løsninger.")
print("Løsningene er: x = (4 ± √64) / 4, som gir x = 2.5 og x = -1.")

import math

def solve_quadratic(a, b, c):
    if c == 0:
        # Løsning når konstantleddet mangler
        print("Løsning når konstantleddet mangler:")
        x1 = 0
        x2 = -b / a
        return x1, x2
    elif b == 0:
        # Løsning når førstegradsleddet mangler
        print("Løsning når førstegradsleddet mangler:")
        if -c / a < 0:
            return "Ingen reell løsning"
        else:
            x1 = math.sqrt(-c / a)
            x2 = -math.sqrt(-c / a)
            return x1, x2
    else:
        # Løsning med ABC-formelen
        print("Løsning med ABC-formelen:")
        discriminant = b**2 - 4*a*c
        if discriminant > 0:
            x1 = (-b + math.sqrt(discriminant)) / (2*a)
            x2 = (-b - math.sqrt(discriminant)) / (2*a)
            return x1, x2
        elif discriminant == 0:
            x1 = -b / (2*a)
            return x1,
        else:
            return "Ingen reell løsning"

# Input-spørsmål
print("For å løse en andregradslikning, vennligst gi verdiene for a, b, og c.")
a = float(input("Hva er verdien for a? "))
b = float(input("Hva er verdien for b? "))
c = float(input("Hva er verdien for c? "))

# Løsning
løsninger = solve_quadratic(a, b, c)
print("Løsningene er:", løsninger)

def get_quadratic_coefficients():
    while True:
        try:
            a = float(input("Skriv inn koeffisienten a (foran x^2): "))
            b = float(input("Skriv inn koeffisienten b (foran x): "))
            c = float(input("Skriv inn konstanten c: "))
            return a, b, c
        except ValueError:
            print("Ugyldig input. Vennligst skriv inn tallverdier for a, b og c.")

def solve_quadratic(a, b, c):
    import cmath
    d = (b**2) - (4*a*c)
    sol1 = (-b - cmath.sqrt(d)) / (2*a)
    sol2 = (-b + cmath.sqrt(d)) / (2*a)
    return sol1, sol2

def profit_calculation():
    print("Oppgave 7")
    print("Beregning av hvor mange blader som må produseres og selges for å gå i overskudd.")
    
    try:
        # Definer kostnads- og inntektsfunksjonene
        def cost_function(x):
            return 0.0015 * x**2 + 20 * x + 50000
        
        def revenue_function(x):
            return -0.001 * x**2 + 50 * x
        
        # Løsning av likningen for overskudd
        # Inntekt = Kostnad => -0.001 * x^2 + 50 * x = 0.0015 * x^2 + 20 * x + 50000
        # Vi setter det lik null og finner x:
        # 0.0015 * x^2 + 20 * x + 50000 + 0.001 * x^2 - 50 * x = 0
        # 0.0025 * x^2 - 30 * x + 50000 = 0
        
        a = 0.0025
        b = -30
        c = 50000
        
        sol1, sol2 = solve_quadratic(a, b, c)
        
        print(f"Løsningene til ligningen 0.0025x^2 - 30x + 50000 = 0 er x = {sol1} og x = {sol2}")
        print("Det betyr at Hans Luftvik må produsere og selge mellom disse to mengdene for å gå i overskudd.")
    
    except Exception as e:
        print(f"En feil oppstod: {e}")

def main():
    while True:
        print("\nVelkommen til løseren for andregradslikninger.")
        print("Velg en oppgave:")
        print("1. Løs en standard andregradslikning")
        print("2. Beregn overskudd for Hans Luftvik sitt flymagasin (Oppgave 7)")
        print("0. Avslutt")
        
        try:
            choice = int(input("Ditt valg: "))
            if choice == 1:
                print("Du har valgt å løse en standard andregradslikning.")
                a, b, c = get_quadratic_coefficients()
                sol1, sol2 = solve_quadratic(a, b, c)
                print(f"Løsningene til ligningen {a}x^2 + {b}x + {c} = 0 er x = {sol1} og x = {sol2}")
            elif choice == 2:
                profit_calculation()
            elif choice == 0:
                print("Avslutter programmet.")
                break
            else:
                print("Ugyldig valg, vennligst prøv igjen.")
        except ValueError:
            print("Ugyldig input. Vennligst skriv inn et tall.")

if __name__ == "__main__":
    main()