master > master: code go - ordner von internal -> pkg umgezogen

code/golang/pkg/algorithms/search/interpol/interpol.go

@@ -0,0 +1,67 @@
+package interpol
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"math"
+
+	"ads/internal/core/logging"
+	"ads/internal/core/metrics"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * ALGORITHM interpolation
+ * ---------------------------------------------------------------- */
+
+/*
+Inputs: L = Liste von Zahlen, x = Zahl.
+
+Annahme: L sei aufsteigend sortiert.
+
+Outputs: Position von x in L, sonst −1 wenn x nicht in L.
+*/
+func InterpolationSearch(L []int, x int, u int, v int) int {
+	if len(L) == 0 {
+		logging.Debug("Liste L leer, also x nicht in L")
+		return -1
+	} else if !(L[u] <= x && x <= L[v]) {
+		logging.Debug("x liegt außerhalb der Grenzen von L")
+		return -1
+	}
+	metrics.AddTimeCost()
+	p := getSuchposition(L, x, u, v)
+	if L[p] == x {
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] == x; ===> Element gefunden", u, v, p)
+		return p
+	} else if x < L[p] {
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] > x; ===> suche in linker Hälfte", u, v, p)
+		return InterpolationSearch(L, x, u, p-1)
+	} else { // } else if x > L[p] {
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] < x; ===> suche in rechter Hälfte", u, v, p)
+		return InterpolationSearch(L, x, p+1, v)
+	}
+}
+
+/* ---------------------------------------------------------------- *
+ * ALGORITHM interpolation
+ * ---------------------------------------------------------------- */
+
+/*
+Inputs: L = Liste von Zahlen, x = Zahl, [u, v] = Suchinterval.
+
+Outputs: Interpolierte Position, um Suchinterval ausgeglichen aufzuteilen.
+*/
+func getSuchposition(L []int, x int, u int, v int) int {
+	metrics.AddTimeCost()
+	r := float64(x-L[u]) / float64(L[v]-L[u])
+	p := int(math.Floor(float64(u) + r*float64(v-u)))
+	return p
+}

code/golang/pkg/algorithms/search/interpol/interpol_fancy.go

@@ -0,0 +1,108 @@
+package interpol
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+
+	"ads/internal/core/metrics"
+	"ads/internal/core/utils"
+	"ads/internal/setup"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * CHECKS
+ * ---------------------------------------------------------------- */
+
+func preChecks(L []int, _ ...interface{}) error {
+	if !utils.IsSortedListInt(L) {
+		return fmt.Errorf("Ungültiger Input: L muss aufsteigend sortiert sein!")
+	}
+	return nil
+}
+
+func postChecks(L []int, x int, index int, _ ...interface{}) error {
+	if utils.ArrayContains(L, x) {
+		if !(index >= 0) {
+			return fmt.Errorf("Der Algorithmus sollte nicht -1 zurückgeben.")
+		}
+		if L[index] != x {
+			return fmt.Errorf("Der Algorithmus hat den falschen Index bestimmt.")
+		}
+	} else {
+		if index != -1 {
+			return fmt.Errorf("Der Algorithmus sollte -1 zurückgeben.")
+		}
+	}
+	return nil
+}
+
+/* ---------------------------------------------------------------- *
+ * ALGORITHM interpolation + Display
+ * ---------------------------------------------------------------- */
+
+func FancyInterpolationSearch(input_L []int, input_x int, input_u int, input_v int) (int, error) {
+	var name = "Interpolationssuchalgorithmus"
+	var inputs = map[string]interface{}{
+		"L": input_L,
+		"x": input_x,
+		"u": input_u,
+		"v": input_v,
+	}
+	var outputs map[string]interface{}
+	var (
+		output_index int
+	)
+	var err error
+
+	do_once := true
+	for do_once {
+		do_once = false
+
+		// Start Message
+		setup.DisplayStartOfAlgorithm(name, inputs)
+
+		// Prechecks:
+		if setup.AppConfigPerformChecks() {
+			err = preChecks(input_L, input_x, input_u, input_v)
+			if err != nil {
+				break
+			}
+		}
+
+		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
+		output_index = InterpolationSearch(input_L, input_x, input_u, input_v)
+		metrics.StopMetrics()
+		outputs = map[string]interface{}{
+			"index": output_index,
+		}
+
+		// Metriken anzeigen
+		if setup.AppConfigShowMetrics() {
+			setup.DisplayMetrics()
+		}
+
+		// End Message
+		setup.DisplayEndOfAlgorithm(outputs)
+
+		// Postchecks:
+		if setup.AppConfigPerformChecks() {
+			err = postChecks(input_L, input_x, output_index)
+			if err != nil {
+				break
+			}
+		}
+	}
+
+	return output_index, err
+}