File size: 5,274 Bytes
710a57f 0cf2b5a 710a57f |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
---
base_model: [nisten/llamagnific-3-87b]
merged_model: [NousResearch/Hermes-2-Pro-Llama-3-70B]
library_name: transformers
tags:
- mergekit
- merge
license: llama3
---
GGUF Files of nisten/llamagnific-3-87b - a 99layer llama-3-70b frankenstein
# base_model: [meta-llama/Meta-Llama-3-70B-Instruct]
# merge_model: [NousResearch/Hermes-2-Pro-Llama-3-70B]
This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
## Merge Details
### Merge Method
This model was merged using the passthrough merge method.
### Models Merged
The following models were included in the merge:
* /home/admin/meta70
* /home/admin/hermes2pro
### Configuration
The following YAML configuration was used to produce this model:
```yaml
dtype: bfloat16
merge_method: passthrough
slices:
- sources:
- layer_range: [0, 15]
model: /home/admin/meta70
- sources:
- layer_range: [10, 69]
model: /home/admin/hermes2pro
- sources:
- layer_range: [55, 80]
model: /home/admin/meta70
```
#TEST PROMPT IS LOOKING INTERESTING
> [!TIP]
> How to build a city on Mars? via aldrin cycler orbit shipments and calculate in assemblyscript some 64bit accurate orbits and shipments between 2025-2035 , output an actual table dont fluff.
>
```assembly
Building a city on Mars is a complex and multi-faceted endeavor that requires a deep understanding of various fields, including orbital mechanics, materials science, and habitat design. Here's a high-level overview of the process, along with some AssemblyScript code to calculate 64-bit accurate orbits and shipments between 2025 and 2035.
**Step 1: Orbital Mechanics and Aldrin Cycler**
The Aldrin cycler is a type of spacecraft that uses a specific orbit to travel between Earth and Mars, making it an energy-efficient option for transporting people and cargo. The cycler's orbit is designed to have a synodic period (the time it takes to complete one round trip) of approximately 2.14 years, which is close to the Earth-Mars synodic period.
To calculate the cycler's orbit, we'll use the vis-viva equation, which relates the orbital velocity of a spacecraft to its position and the central body's gravitational parameter (μ). The equation is:
v = sqrt(μ \* (2/r - 1/a))
where:
v = orbital velocity
μ = standard gravitational parameter (for Earth, μ = 3.986004418e+14 m³/s²)
r = position vector (distance from the central body)
a = semi-major axis of the orbit
Here's an AssemblyScript function to calculate the cycler's orbit:
(import "env" "console_log" (func $console_log (result i32) (i32)))
(memory (import "env" "memory") 1)
(data (i32.const 0) "\0A\00\00\00")
@; Calculate the cycler's orbit
@; Args: r (f64) - position vector (distance from the central body)
@; a (f64) - semi-major axis of the orbit
@; Returns: v (f64) - orbital velocity
(func $cycler_orbit (param $r f64) (param $a f64) (result f64)
(f64.mul
(f64.const 3.986004418e+14)
(f64.sub
(f64.div
(f64.const 2)
(f64.copy $r)
)
(f64.div
(f64.const 1)
(f64.copy $a)
)
)
)
)
@; Example usage: Calculate the cycler's velocity at a position of 1.5 AU
@; (1 AU = 1.496e+11 m) and a semi-major axis of 2.4 AU
(f64.print
(call $cycler_orbit
(f64.mul (f64.const 1.5) (f64.const 1.496e+11))
(f64.mul (f64.const 2.4) (f64.const 1.496e+11)))
)
)
**Step 2: Assembly and Construction**
Once you've calculated the cycler's orbit, you'll need to assemble and construct the city on Mars. This will involve designing habitats, life support systems, and infrastructure to support human habitation.
**Step 3: Table of Shipments**
To create a table of shipments between 2025 and 2035, you'll need to determine the number of cyclers, the cargo capacity of each cycler, and the frequency of shipments. Here's a simple AssemblyScript function to calculate the total cargo capacity over a given period:
@; Calculate the total cargo capacity over a given period
@; Args: num_cyclers (i64) - number of cyclers
@; cargo_capacity (f64) - cargo capacity of each cycler (in tons)
@; start_year (i64) - start year (e.g., 2025)
@; end_year (i64) - end year (e.g., 2035)
@; Returns: total_capacity (f64) - total cargo capacity (in tons)
(func $total_cargo_capacity (param $num_cyclers i64) (param $cargo_capacity f64) (param $start_year i64) (param $end_year i64) (result f64)
(f64.mul
(f64.conv_i64_f64
(i64.sub
(get_local $end_year)
(get_local $start_year)
)
)
(f64.conv_i64_f64
(get_local $num_cyclers)
)
(f64.copy $cargo_capacity)
)
)
@; Example usage: Calculate the total cargo capacity for 2 cyclers with a capacity of 500 tons each, between 2025 and 2035
(f64.print
(call $total_cargo_capacity
(i64.const 2)
(f64.const 500)
(i64.const 2025)
(i64.const 2035)
)
)
This is a high-level overview of the process, and there are many more details to consider when building a city on Mars. However, this should give you a starting point for understanding the orbital mechanics and assembly aspects of the project.
``` |