Täpp-Anders - Användarbidrag [sv]

Svensk stilmall

2026-05-12T09:01:36Z

Anders:

<pre>

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ichiswedish.sty version 1.2 date 09-JUL-2000 %
% %
% This style is to typeset Swedish documents in LaTeX. It is designed %
% with and works well in the MikTeX environment, however it should not %
% be difficult to get it working well in other environments either. %
% %
% Any suggestions you might have on this are welcome, plese send them %
% to the following email address <anders@sikvall.se> and I will %
% consider incorporating them to the next release %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Packages that we want to be loaded ALL THE TIME %
% when typesetting swedish text. %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Swedish typography
\usepackage[swedish]{babel}

% Input encodings, make it easier to encode special latin
% characters like å ä ö Å Ä Ö by typing them instead of
% using {\"a} for ä &c.
\usepackage[ansinew]{inputenc}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Settings specially for swedish %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Decimal comma
\mathchardef\CommaOrdinary="013B
\mathchardef\CommaPunct ="613B
\mathcode`,="8000
{\catcode`\,=\active
\gdef ,{\obeyspaces\futurelet\next\CommaCheck}}
\def\CommaCheck{\if\space\next\CommaPunct\else\CommaOrdinary\fi}

% Get rid of the spacing used in english typesetting
\frenchspacing

% Paragraph indentation style
\setlength{\parindent}{1em}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Common abbreviations in Swedish %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\usepackage{xspace}
\newcommand{\bla}{bl.\hspace{0.1em}a.\xspace}
\newcommand{\ca}{ca\xspace}
\newcommand{\dvs}{dvs.\xspace}
\newcommand{\etc}{etc.\xspace}
\newcommand{\kl}{kl.\xspace}
\newcommand{\mfl}{m.\hspace{0.1em}fl.\xspace}
\newcommand{\mm}{m.\hspace{0.1em}m.\xspace}
\newcommand{\obs}{obs.\xspace}
\newcommand{\osv}{osv.\xspace}
\newcommand{\pga}{p.\hspace{0.1em}g.\hspace{0.1em}a.\xspace}
\newcommand{\sk}{s.\hspace{0.1em}k.\xspace}
\newcommand{\tillex}{t.\hspace{0.1em}ex.\xspace}

% END
</pre>
[[category:LaTeX]]

Brevmall

2026-05-12T08:59:48Z

Anders:

[[category:LaTeX]]
Detta är min standard brevmall som jag använder tillsammans med [[Svensk stilmall]] när jag skriver brev i LaTeX.

<pre>
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Letter Template for LaTeX
%%
%% Anders Sikvall
%% (C)2003 - Free for Personal use
%%
%% Improvmenets welcome, email to anders@sikvall.se please.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\documentclass[a4paper, 12pt, oneside]{letter}
\usepackage{a4}
\usepackage[ansinew]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[swedish]{babel}
%\usepackage{palatino}
%\usepackage{bookman}
%\usepackage{utopia}
\usepackage{times}
%\usepackage{newcent}
%\usepackage{charter}
%\usepackage{avant}
%\usepackage{chancery}
%\usepackage{euler}
\name{YOUR NAME}
\signature{YOUR NAME/SIGNATURE}
\address{YOUR NAME AND ADDRESS}

\begin{document}

\begin{letter}{TO WHOM}
%% \begin{raggedright}
\opening{\underline{\textbf{START OF LETTER}}}

\closing{YOUR NAME}

% If you want to enclose other documents, specify them here.
%% \encl{Bilaga 1}

\end{letter}
\end{document}
</pre>

IP3

2026-05-12T08:20:52Z

Anders:

= Tredje ordningens skärningspunkt =

Kan definieras antingen som en harmonisk produkt till en enkel ton, eller som de två IM3-produkter som uppträder vid två stycken signaler genom en icke-linjär krets. När man ökar nyttosignalens storlek växer IM3 med 3 dB per dB nyttosignalerna ökas. Därför uppstår en skärningspunkt så småningom och det är denna som definieras som IP3 (intercept point 3rd order).

Med alla enheter i dB får vi följande:

<math> \text{OIP}_3 = P + \Delta \text{IM}_3 / 2 </math>

Där <math>\Delta \text{IM}_3</math> är hyr mycket högre nyttosignalen är från den högsta intermodulationsprodukten. Dvs om du har en nyttosignal på 30 dBm vilket ger en IM3 produkt på -36 dBm blir formeln

<math> \text{OIP}_3 = 30 \text{ dBm} + 66 \text{ dBc} / 2 = 63 \text{ dBm} </math>

= Tredje ordningens IM-produkter =

Formlerna ger de frekvenser som IM3 uppstår vid om man sänder 2 st signaler med frekvenserna f1 och f2 genom en ickelinjär krets:

<math>\text{IP}_{3:1} = 2f_1-f_2</math>

<math>\text{IP}_{3:2}=2f_2-f_1</math>

[[category:Radio]]
[[category:Fysik]]
[[Category:Formelsamling]]
[[category:IM3]]
[[category:IP3]]
[[category:Intermodulation]]

IP3

2026-05-12T08:14:38Z

Anders:

= Tredje ordningens skärningspunkt =

Kan definieras antingen som en harmonisk produkt till en enkel ton, eller som de två IM3-produkter som uppträder vid två stycken signaler genom en icke-linjär krets. När man ökar nyttosignalens storlek växer IM3 med 3 dB per dB nyttosignalerna ökas. Därför uppstår en skärningspunkt så småningom och det är denna som definieras som IP3 (intercept point 3rd order).

Denna kan beräknas enligt:

<math> OIP3 = P + IM_{3} / 2 </math>

= Tredje ordningens IM-produkter =

Formlerna ger de frekvenser som IM3 uppstår vid om man sänder 2 st signaler med frekvenserna f1 och f2 genom en ickelinjär krets:

<math>\text{IP}_{3:1} = 2f_1-f_2</math>

<math>\text{IP}_{3:2}=2f_2-f_1</math>

[[category:Radio]]
[[category:Fysik]]
[[Category:Formelsamling]]
[[category:IM3]]
[[category:IP3]]
[[category:Intermodulation]]

Okamura-Hata formel för urban radioutbredning

2026-05-12T08:08:38Z

Anders:

== Bakgrund ==

Utbredningsformeln för [[Friis formel för frirumsutbredning|frirumsutbredning]] fungerar inte särskilt bra i urbana miljöer och därför sökte herrarna Okamura och Hata efter en förbättrad variant. Efter många praktiska prov kom man fram till att man approximera utbredningen på större avstånd enligt följande formel:

<math>\mathrm{FSPL}=20\log_{10}{(f)} + (20+K)\log_{10}{(d)} + 32,45</math>

Där:
:''f'' är frekvensen [MHz]
:''d'' är avståndet mellan sändare och mottagare [km]
:''K'' är den så kallade Okamura-Hata-konstanten

Konstanten 32,45 kan härledas ur den klassiska formeln för [[Friis formel för frirumsutbredning|Free space path loss]] med enheterna i MHz och km i stället för exempelvis Hz och meter.

Konstanten K antar olika värden beroende på terrängens beskaffenhet:

<table border="1" cellspacing="0" cellpadding="5">
<tr>
<th>Värde för K</th>
<th>Terrängtyp</th>
<th>Anm.</th>
</tr>
<tr>
<td>10</td>
<td>Lätt urban</td>
<td>Villaområden, svagt kuperad terräng, inga större hinder</td>
</tr>
<tr>
<td>15</td>
<td>Urban</td>
<td>Stadskärnor med lite andel höghus, ibland större hinder</td>
</tr>
<tr>
<td>20</td>
<td>Metropolis</td>
<td>Tung urban miljö, företrädelsevis höghus, Manhattan, stora hinder</td>
</tr><tr>
<td>30</td><td>Öken</td><td>Mycket torra områden, stenöken</td>
</tr>
</table>

[[category:Radio]]
[[category:Formelsamling]]
[[category:Trådlös kommunikation]]
[[category:Telekommunikation]]
[[category:Vågutbredning]]
[[category:Okamura-Hata]]

Fältstyrka

2026-05-12T07:48:37Z

Anders:

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]
[[category:Närfält]]
[[category:Fjärrfält]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>H = \frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| I || Elektrisk ström || A
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|-
| D || Antennarea || m²
|-
| r || Avstånd || m
|}

Fältstyrka

2026-05-12T07:47:51Z

Anders: /* Storhetssamling */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>H = \frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| I || Elektrisk ström || A
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|-
| D || Antennarea || m²
|-
| r || Avstånd || m
|}

Fältstyrka

2026-05-12T07:47:23Z

Anders: /* Direkt från sändaren */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>H = \frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| I || Elektrisk ström || A
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|-
| D || Antennarea || m²
|-
| r || Sträcka || m
|}

Fältstyrka

2026-05-12T07:47:09Z

Anders: /* Storhetssamling */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| I || Elektrisk ström || A
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|-
| D || Antennarea || m²
|-
| r || Sträcka || m
|}

Fältstyrka

2026-05-12T07:46:40Z

Anders: /* Storhetssamling */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|-
| D || Antennarea || m²
|-
| r || Sträcka || m
|}

Fältstyrka

2026-05-12T07:45:59Z

Anders: /* Bakgrund */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

== Fjärrfältsdefinition ==

För fjärrfältet används vanligen följande approximation vid vilket avstånd från en antenn som vi kan säga iss vara i fjärrfältet:

<math> r > \frac{2D^2}{\lambda}</math>

Där D är antennens största utbredning i rummet i meter, för den dipol den totala längden, för en Yagi-Uda dess längsta axel, för en parabol omkretsen och <math>\lambda</math> är våglängden i meter. <math>D^2</math> är ett mått på antennens "antennarea" och säger något om fältbildning och utbredning i rummet.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|}

Fältstyrka

2026-05-12T07:42:49Z

Anders: /* Elektrisk fältstyrka */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m. Detta gäller i fjärrfältet.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|}

Fältstyrka

2026-05-12T07:38:13Z

Anders: /* Magnetisk fältstyrka */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

== Från elektriska fältet ==

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

== Direkt från sändaren ==

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

== Nära en elektrisk ledare ==

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|}

Fältstyrka

2026-05-12T07:37:24Z

Anders: /* Storhetssamling */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter på denna sida
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|}

Fältstyrka

2026-05-12T07:37:06Z

Anders: /* Storhetssamling */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

{| class="wikitable" style="margin:auto"
|+ Storheter och enheter
|-
! Storhet!! Beteckning!! Enhet
|-
| S || Effektdensitet|| W/m²
|-
| E || Elektrisk fältstyrka || V/m
|-
| H || Magnetisk fältstyrka || A/m
|-
| P || Sändarens effekt || W
|-
| G || Antennens förstärkningsfaktor || (dimensionslös)
|}

Fältstyrka

2026-05-12T07:25:19Z

Anders: /* Magnetisk fältstyrka */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>\frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

TODO: Samla storheterna här

Fältstyrka

2026-05-12T07:25:02Z

Anders: /* Magnetiska fältstyrkan */

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetisk fältstyrka =

Om du redan beräknat den elektriska fältstyrkan kan den magnetiska beräknas så som:

<math>H = \frac{E}{377} </math>

Annars från sändarens effekt P och antennens antennvinst G fås:

<math>H = \frac{E}{377} \approx \frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}</math>

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

TODO: Samla storheterna här

Fältstyrka

2026-05-12T07:24:01Z

Anders:

[[category:formelsamling]]
[[category:fältstyrka]]
[[category:ellära]]
[[category:radio]]
[[category:radiolära]]
[[category:magnetism]]
[[category:elektricitet]]

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Effekttäthet =

Effekttätheten <math>S</math> i enenheten W/m² kan beräknas ur sambandet:

<math>
S = \frac{P \cdot G}{2 \pi r^2}
</math>

= Elektrisk fältstyrka =

Den elektriska fältstyrkan uttrycks i regel som V/m eller i varianter därav. Vanliga varianter är t.ex. dBµV/m.

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

= Magnetiska fältstyrkan =

<math>
H = \frac{E}{377} \approx \frac{\sqrt{30 \cdot P \cdot G}}{377 \cdot r}
</math>

Nära en elektrisk ledare, till exempel drivet element hos en antenn så beräknas först strömmen i ledaren och därefter fås magnetfältet med relationen:

<math>
H = \frac{I}{2 \pi r}
</math>

= Storhetssamling =

TODO: Samla storheterna här

Fältstyrka

2026-05-11T17:11:59Z

Anders: Skapade sidan med '= Bakgrund = Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat. = Formel = <math> E= \frac{ \sqrt{30 \cdot P \cdot G} } { r } </math> Där <math>E</math> är fältstyrkan i V/m och <math>P</math> är effekten hos sändaren i W samt <math>G</math> är antennens antennvinst i bästa riktningen (linj...'

= Bakgrund =

Fältstyrkan av en radiosignal avtar linjärt med avståndet från en sändare. Denna kan räknas ut med en enkel formel som stämmer utmärkt i fjärrfältet från antennen. I närfältet är det mer komplicerat.

= Formel =

<math>
E= \frac{ \sqrt{30 \cdot P \cdot G} } { r }
</math>

Där <math>E</math> är fältstyrkan i V/m 
och <math>P</math> är effekten hos sändaren i W 
samt <math>G</math> är antennens antennvinst i bästa riktningen (linjärt, ej i dB).

Racket/Erastothenes

2026-05-07T07:05:13Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Erastothenes såll implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;; Skapar en vektor där indexet motsvarar talet.
;; Om (vector-ref v n) är #t, så är n ett primtal.

(define (make-sieve limit)
(define sieve (make-vector (add1 limit) #t))

;; 0 och 1 är aldrig primtal
(when (>= limit 0) (vector-set! sieve 0 #f))
(when (>= limit 1) (vector-set! sieve 1 #f))

;; Vi behöver bara gå upp till kvadratroten av limit
(for ([p (in-range 2 (add1 (integer-sqrt limit)))])
(when (vector-ref sieve p)
;; Markera alla multiplar av p som falska (starta vid p*p)
(for ([multiple (in-range (* p p) (add1 limit) p)])
(vector-set! sieve multiple #f))))
;; returnera sållet till anroparen
sieve)

;; Returnerar en lista med alla primtal mellan start och stop
(define (primes-between start stop)
(if (> start stop)
'() ;Returnerar tomt om start > stop
(let ([is-prime? (make-sieve stop)])
(for/list ([n (in-range (max start 2) (add1 stop))]
#:when (vector-ref is-prime? n))
n))))

;; Testkörning
(primes-between 10 50)

</pre>

MSMTP för Protonmail

2026-04-25T10:44:17Z

Anders:

[[category:Protonmail]]
[[category:Proton]]
[[category:Linux]]
[[category:Hack]]
[[category:MSMTP]]
[[category:MTA]]
[[category:Mail]]

= SMTP token =

Först behöver du logga in i tjänsten och generera ett SMTP Token för att använda med Protonmail annars kommer inte detta fungera utan att installera [[Proton Mail Bridge]] eller liknande.

Vi kommer använda special@domain.com i denna text.

= Installation =

Installera följande komponenter:

<pre>sudo apt install msdmtp smstp-mta mailutils bsd-mailx -y</pre>

= MSMTP Konfigurationsfil =

<pre>/etc/msmtprc</pre>

<pre>
defaults
tls on

account default
host smtp.protonmail.ch
port 587
from special@domain.org
set_from_header on
auth on
user special@domain.org
password SMTP_TOKEN_GOES_HERE
auth plain
</pre>

Filrättigheter 0660 och inget annat.
Ägare till filen root:msmtp.

= Konfigurera MTA =

<pre>/etc/mail.rc</pre>

Lägg till raden:

<pre>set mta /usr/bin/msmtp</pre>

Du kan även sätta upp alias om du behöver det.

<pre>
root: master@domain.org
caroline: caroline@example.com
default: admin@domain.org
</pre>

MSMTP för Protonmail

2026-04-25T10:43:38Z

Anders: Skapade sidan med 'category:Protonmail category:Proton category:Linux category:Hack = SMTP token = Först behöver du logga in i tjänsten och generera ett SMTP Token för att använda med Protonmail annars kommer inte detta fungera utan att installera Proton Mail Bridge eller liknande. Vi kommer använda special@domain.com i denna text. = Installation = Installera följande komponenter: <pre>sudo apt install msdmtp smstp-mta mailutils bsd-mailx -y</pre>...'

[[category:Protonmail]]
[[category:Proton]]
[[category:Linux]]
[[category:Hack]]

= SMTP token =

Först behöver du logga in i tjänsten och generera ett SMTP Token för att använda med Protonmail annars kommer inte detta fungera utan att installera [[Proton Mail Bridge]] eller liknande.

Vi kommer använda special@domain.com i denna text.

= Installation =

Installera följande komponenter:

<pre>sudo apt install msdmtp smstp-mta mailutils bsd-mailx -y</pre>

= MSMTP Konfigurationsfil =

<pre>/etc/msmtprc</pre>

<pre>
defaults
tls on

account default
host smtp.protonmail.ch
port 587
from special@domain.org
set_from_header on
auth on
user special@domain.org
password SMTP_TOKEN_GOES_HERE
auth plain
</pre>

Filrättigheter 0660 och inget annat.
Ägare till filen root:msmtp.

= Konfigurera MTA =

<pre>/etc/mail.rc</pre>

Lägg till raden:

<pre>set mta /usr/bin/msmtp</pre>

Du kan även sätta upp alias om du behöver det.

<pre>
root: master@domain.org
caroline: caroline@example.com
default: admin@domain.org
</pre>

Automatiskt tömma soptunnan

2026-04-25T10:37:05Z

Anders:

[[category:Linux]]
[[category:Tips och tricks]]
[[category:Hack]]

Börja med att installera följande paket:

<pre>sudo apt install trash-cli</pre>

Därefter lägger du till följande rad i crontab:

<pre>crontab -e</pre>

<pre>00 * * * * /usr/bin/trash-empty 7</pre>

Spara filen och avsluta editorn. Du kan eventuellt behöva modifiera sökvägen till trash-empty,
på vissa system är det /bin/trash-empty.

Automatiskt tömma soptunnan

2026-04-25T10:36:25Z

Anders: Skapade sidan med 'category:Linux category:Tips och tricks Börja med att installera följande paket: <pre>sudo apt install trash-cli</pre> Därefter lägger du till följande rad i crontab: <pre>crontab -e</pre> <pre>00 * * * * /usr/bin/trash-empty 7</pre> Spara filen och avsluta editorn. Du kan eventuellt behöva modifiera sökvägen till trash-empty, på vissa system är det /bin/trash-empty.'

[[category:Linux]]
[[category:Tips och tricks]]

Börja med att installera följande paket:

<pre>sudo apt install trash-cli</pre>

Därefter lägger du till följande rad i crontab:

<pre>crontab -e</pre>

<pre>00 * * * * /usr/bin/trash-empty 7</pre>

Spara filen och avsluta editorn. Du kan eventuellt behöva modifiera sökvägen till trash-empty,
på vissa system är det /bin/trash-empty.

Huvudsida

2026-04-25T10:33:37Z

Anders: /* Linux */

= Om mig =

Ansvarig för denna Wiki är Anders Sikvall
[mailto:anders@sikvall.se anders@sikvall.se] (Proton mail krypterad)

Du kan hitta min PGP/GPG-nyckel på denna URL:
[https://sikvall.se/pgp/anders@sikvall.se https://sikvall.se/pgp/anders@sikvall.se]

Min hemsida finns på:
[https://sikvall.se/ https://sikvall.se/]

= Specialsidor =

Specialsidor är länkar till sidor som omfattar meta-information.

* [[:Special:Categories|Alla kategorier]]
* [[:Special:AllPages|Alla sidor]]
* [[dBµV/m]]

= Särskilt utvalda sidor =
* [[GPG]]
== Programmering ==

* [[Fisher-Yates Shuffle]]
* [[Base64]] [[Base32]] [[Base24]]
* [[Racket]]

== Elektronik ==

* [[Peukerts lag]] - [[Blyackumulator laddningstabell]]
* [[Pi-dämpare]]

== Radiorelaterat ==

* [[Amatörradio]]
* [[Jaktradio 155 MHz]] - [[PMR446]] - [[KDR 444]]
* [[Q-koden]] - [[Morsealfabetet]] - [[Svenska bokstaveringsalfabetet]]
* [[AM]] - [[FM]] - [[SSB]] - [[CW]]

== Linux ==

* [[Diskimage i Linux]]
* [[Git]]
* [[Temporär download]]
* [[Swapfil i BTRFS]]
* [[Automatiskt tömma soptunnan]]

== LaTeX Dokumentation ==

* [[Brevmall]]
* [[Svensk stilmall]]
* [[Tips och Tricks i LaTeX]]

== Friluftsliv ==
* [[:category:Pannlampor|Pannlampor]]

<math>L_f</math>

Racket/3D-boll

2026-04-24T15:25:27Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

= Version "snurra själv" =

<pre>
#lang racket
(require plot)
(require racket/pretty)
;; En pixelboll iracket
;; Från Buzzern skrivet under påskhelgen

(define π (acos -1))
(define VERTICAL-SPLIT 16)
(define HORIZONTAL-SPLIT 16)
(define PARTICLE-SIZE (* VERTICAL-SPLIT HORIZONTAL-SPLIT))
(define particles (for/vector ([i (in-range PARTICLE-SIZE)])
(make-vector 3)))

;; from scheme.com since normal scheme lacks for/vector
(define make-matrix
(lambda (rows columns)
(do ((m (make-vector rows))
(i 0 (+ i 1)))
((= i rows) m)
(vector-set! m i (make-vector columns)))))

(define (to->deg rad)
(* rad (/ 180 π)))

(define (print-dots amount)
(let myloop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(myloop (+ count 1))))))

(define (generate-xyz radius θ ϕ)
(let* ([x (* radius (sin θ) (cos ϕ))]
[y (* radius (sin θ) (sin ϕ))]
[z (* radius (cos θ))]
)
(vector x y z)))

(define (test-loop amount)
(let loop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(loop (+ count 1))))))

(define (get-angle index split)
(* 2 π index (/ split)))

(define (generate-dots particles)
(let* ([index-y -1])
(for ([row (in-vector particles)]
[index (in-naturals)])
(set! index-y (if (= 0 (modulo index HORIZONTAL-SPLIT))
(+ index-y 1)
index-y))
;(printf " ~a ~a\n" (modulo index HORIZONTAL-SPLIT) index-y)
(define new-θ (get-angle (modulo index HORIZONTAL-SPLIT) HORIZONTAL-SPLIT))
(define new-ϕ (get-angle (modulo index-y VERTICAL-SPLIT) VERTICAL-SPLIT))
(printf " ~a ~a \n" (to->deg new-θ) (to->deg new-ϕ))
;;(vector-set! row 0 )
(vector-set! particles index (generate-xyz 1.0 new-θ new-ϕ)))))

;;(test-loop HORIZONTAL-SPLIT)
;;(generate-xyz 1 π (* 2.0 π))
(generate-dots particles)
(plot3d (points3d particles))

</pre>

= Version "snurrar själv" =

<pre>
#lang racket
(require plot)
(require racket/gui/base)
(require racket/pretty)
;; En pixelboll i racket
;; Från Buzzern skrivet under påskhelgen

(define π (acos -1))
(define HEIGHT 600)
(define WIDTH 800)
(define VERTICAL-SPLIT 16)
(define HORIZONTAL-SPLIT 16)
(define RADIUS 100.0)
(define PARTICLE-SIZE (* VERTICAL-SPLIT HORIZONTAL-SPLIT))
(define particles (for/vector ([i (in-range PARTICLE-SIZE)])
(make-vector 3)))

;; from scheme.com since normal scheme lacks for/vector
(define make-matrix
(lambda (rows columns)
(do ((m (make-vector rows))
(i 0 (+ i 1)))
((= i rows) m)
(vector-set! m i (make-vector columns)))))

(define (to->deg rad)
(* rad (/ 180 π)))

(define (to->rad deg)
(/ (* deg π) 180 ))

(define (print-dots amount)
(let myloop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(myloop (+ count 1))))))

(define (generate-xyz radius θ ϕ)
(let* ([x (* radius (sin θ) (cos ϕ))]
[y (* radius (sin θ) (sin ϕ))]
[z (* radius (cos θ))]
)
(vector x y z)))

(define (projection x y z width height)
(let* ([camera-distance 300.0] ; Push the object away from the camera
[scale-factor 250.0] ; Keep the object visible after pushing it back
; Translate Z away from the viewer
[z-translated (+ z camera-distance)]
; Prevent divide-by-zero (just in case a point hits exactly 0)
[z-safe (if (= z-translated 0.0) 0.001 z-translated)]

; Perspective projection with scaling
[xp (* x (/ scale-factor z-safe))]
[yp (* y (/ scale-factor z-safe))])
;over to screen coords
(vector (+ xp (/ width 2.0)) (+ (/ height 2.0) yp))
))

(define (get-angle index split)
(* 2 π index (/ split)))

(define (generate-dots particles)
(let* ([index-y -1])
(for ([row (in-vector particles)]
[index (in-naturals)])
(set! index-y (if (= 0 (modulo index HORIZONTAL-SPLIT))
(+ index-y 1)
index-y))
(define new-θ (get-angle (modulo index HORIZONTAL-SPLIT) HORIZONTAL-SPLIT))
(define new-ϕ (get-angle (modulo index-y VERTICAL-SPLIT) VERTICAL-SPLIT))
(vector-set! particles index (generate-xyz RADIUS new-θ new-ϕ)))))

(define (rotateX x y z angle)
(let ([y-new (-(* y (cos angle)) (* z (sin angle)))]
[z-new (+ (* y (sin angle)) (* z (cos angle)))])
(vector x y-new z-new)))

(define (rotateY x y z angle)
(let ([x-new (+(* x (cos angle)) (* z (sin angle)))]
[z-new (+ (* (- x) (sin angle)) (* z (cos angle)))])
(vector x-new y z-new)))

(define angleX 0.1)
(define angleXspeed 0)
(define angleY 0.1)
(define angleYspeed 0)

(define deltaTime (current-milliseconds))
(define my-pen (new pen% [color "blue"] [width 2]))

(define (paint canvas dc)
(send dc clear)
(send dc set-pen
my-pen)
(for ([row (in-vector particles)])
(let* ([rotX (rotateX (vector-ref row 0) (vector-ref row 1) (vector-ref row 2) (to->rad angleXspeed))]
[rotY (rotateY (vector-ref rotX 0) (vector-ref rotX 1) (vector-ref rotX 2) (to->rad angleYspeed))]
[xy (projection (vector-ref rotY 0) (vector-ref rotY 1) (vector-ref rotY 2) WIDTH HEIGHT)])
(send dc draw-point (vector-ref xy 0) (vector-ref xy 1)))))

(define frame (new frame% [label "Animation"] [width WIDTH] [height HEIGHT]))
(define canvas (new canvas% [parent frame] [paint-callback paint]))

(generate-dots particles)

(define timer (new timer% [notify-callback
(lambda ()
;(set! x (add1 x))
(set! deltaTime (- (current-milliseconds) deltaTime))
(set! angleXspeed (* angleX deltaTime))
(set! angleYspeed (* angleY deltaTime))
;(printf "~a\n" (current-milliseconds))
(send canvas refresh)
;(send timer start 16)
)]
[interval #f]
[just-once? #f]
))
(send frame show #t)
(send timer start 16) ; ~60 FPS in best case i guess...

</pre>

Racket/Posits

2026-04-24T15:25:19Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; En enkel implementation av Posists eller Unum typ III
;; i Racket för skojs skull och för att lära sig mer
;;
;; Täpp-Anders Sikvall anders@sikvall.se 2026-04-04
;;
;; Posit representeras som ett heltal (bitmönster, 0 till 2^n-1).
;; Parametrar: n = totalt antal bits, es = antal exponent-bits (t.ex. n=16, es=1 för posit16).
;; Innehåller:
;; * Konvertering till/från generiska tal (number->posit och posit->number)
;; * Addition, subtraktion, multiplikation och division av posits
;;
;; Aritmetiken är implementerad via konvertering till reellt tal + operation + tillbaka till posit
;; (enkel approach som bevarar tapered precision via rounding vid varje steg).
;; Full bit-exakt aritmetik (alignera regime/exponent etc.) är mer komplex och lämnas som utökning.
;; Algoritmen för number->posit är översatt direkt från Gustafsons x2p i "Posits4.pdf".
;; posit->number använder full fält-extraktion (regime, exponent, fraction).

(define (number->posit x n es)
;; x2p-algoritmen från Gustafson (översatt till Racket)
;; Returnerar posit-bitmönster som heltal.
(cond
[(= x 0) 0]
[(infinite? x) (arithmetic-shift 1 (- n 1))]
[else
(let* ([nbits n]
[npat (expt 2 nbits)]
[useed (expt 2 (expt 2 es))]
[y (abs x)]
[p 0]
[i 0]
[e-val (- (expt 2 es) 1)])
;; Northeast/southeast quadrant (regime-byggnad)
(if (>= y 1)
(begin
(set! p 1)
(set! i 2)
(let loop-regime ()
(when (and (>= y useed) (< i nbits))
(set! p (+ (* 2 p) 1))
(set! y (/ y useed))
(set! i (add1 i))
(loop-regime)))
(set! p (* 2 p))
(set! i (add1 i)))
(begin
(set! p 0)
(set! i 1)
(let loop-regime ()
(when (and (< y 1) (<= i nbits))
(set! y (* y useed))
(set! i (add1 i))
(loop-regime)))
(if (>= i nbits)
(begin
(set! p 2)
(set! i (add1 nbits)))
(begin
(set! p 1)
(set! i (add1 i))))))
;; Exponent-extraktion
(let loop-exp ()
(when (and (> e-val 0.5) (<= i nbits))
(set! p (* 2 p))
(when (>= y (expt 2 e-val))
(set! y (/ y (expt 2 e-val)))
(set! p (add1 p)))
(set! e-val (/ e-val 2))
(set! i (add1 i))
(loop-exp)))
(set! y (- y 1))
;; Fraction-bits
(let loop-frac ()
(when (and (> y 0) (<= i nbits))
(set! y (* 2 y))
(set! p (+ (* 2 p) (floor y)))
(set! y (- y (floor y)))
(set! i (add1 i))
(loop-frac)))
;; Skift och rounding (nearest, tie to even)
(set! p (* p (expt 2 (- (+ nbits 1) i))))
(set! i (add1 i))
(let* ([round-bit (bitwise-and p 1)])
(set! p (floor (/ p 2)))
(set! p (cond
[(= round-bit 0) p]
[(= y 0) (+ p (bitwise-and p 1))] ;; tie to even
[else (add1 p)])))
;; Negativt tal: 2's complement (npat - p)
(set! p (modulo (if (< x 0) (- npat p) p) npat))
p)]))

(define (posit->number p n es)
;; Full decode enligt Gustafson/Unum Type III
;; Returnerar exakt reellt tal (flonum för enkelhet, men kan utökas till rational).
(cond
[(= p 0) 0]
[(= p (arithmetic-shift 1 (- n 1))) +inf.0] ;; NaR / ∞
[else
(let* ([sign (if (zero? (bitwise-and p (arithmetic-shift 1 (- n 1)))) 1 -1)]
[abs-p (if (= sign 1)
p
(bitwise-and (+ (bitwise-not p) 1) (- (expt 2 n) 1)))]
[useed (expt 2 (expt 2 es))])
;; Extrahera regime (runlength m av identiska bits)
(let*-values ([(r m) (let ([first-r (bitwise-and (arithmetic-shift abs-p (- (- n 2))) 1)])
(let loop ([pos (- n 2)]
[m 0])
(if (or (< pos -1) (> m n))
(values first-r m)
(let ([bit (bitwise-and (arithmetic-shift abs-p (- pos)) 1)])
(if (= bit first-r)
(loop (sub1 pos) (add1 m))
(values first-r m))))))])
(let* ([k (if (= r 0) (- m) (- m 1))]
;; Regime-field tar m + 1 bits (run + terminator)
[regime-bits-used (+ m 1)]
[exp-start-pos (- (- n 2) regime-bits-used)] ;; första exp-bit (MSB)
;; Ta upp till es exp-bits (pad low bits med 0 om färre)
[exp-bits (if (< exp-start-pos 0)
0
(let loop ([pos exp-start-pos]
[bits-left es]
[e-acc 0])
(if (or (<= bits-left 0) (< pos -1))
e-acc
(let ([bit (bitwise-and (arithmetic-shift abs-p (- pos)) 1)])
(loop (sub1 pos)
(sub1 bits-left)
(+ (* e-acc 2) bit))))))]
[exp-used (min es (max 0 (+ (- n 1) exp-start-pos)))] ;; tillgängliga bits
[f-start-pos (- exp-start-pos exp-used)]
;; Fraction (remaining bits, hidden 1.)
[f (if (< f-start-pos 0)
0
(let loop ([pos f-start-pos]
[f-acc 0]
[fsize 0])
(if (< pos -1)
f-acc
(let ([bit (bitwise-and (arithmetic-shift abs-p (- pos)) 1)])
(loop (sub1 pos)
(+ (* f-acc 2) bit)
(add1 fsize))))))]
[fsize (max 0 (- n 1 regime-bits-used exp-used))] ;; antal fraction-bits
[significand (+ 1 (/ f (expt 2 fsize)))])
(* sign (expt useed k) (expt 2 exp-bits) significand))))]))

;; Aritmetik (enkel via realtal + rounding till posit)
(define (posit+ p1 p2 n es)
(number->posit (+ (posit->number p1 n es) (posit->number p2 n es)) n es))

(define (posit- p1 p2 n es)
(number->posit (- (posit->number p1 n es) (posit->number p2 n es)) n es))

(define (posit* p1 p2 n es)
(number->posit (* (posit->number p1 n es) (posit->number p2 n es)) n es))

(define (posit/ p1 p2 n es)
(number->posit (/ (posit->number p1 n es) (posit->number p2 n es)) n es))

;; Exempel på användning (kommentera bort eller kör i REPL):
;; (define n 16)
;; (define es 1)
;; (define a (number->posit 3.14 n es)) ;; -> posit för 3.14
;; (define b (number->posit 2.0 n es))
;; (posit+ a b n es) ;; addition
;; (posit->number a n es) ;; tillbaka till tal
</pre>

Racket/Neural

2026-04-24T15:25:12Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Neuralt nät implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;;;;; NEURALT NÄT
;;;
;; Detta program implementerar ett litet neuralt nät och tränar det på sannings-
;; tabellen för XOR. Efter några tusen epoker ska prediktionerna ligga extremt nära
;; följande:
;;
;; a,b → a XOR b
;; 0,0 → 0
;; 0,1 → 1
;; 1,0 → 1
;; 1,1 → 0
;;
;; Implementationen har två input-neuroner för a och b
;; det finns 5 interna (dolda neuroner) som tränas av indatat
;; det finns 1 output-neuron som ger svaret
;;
;;;;; Kodens uppbyggnad och de olika funktionernas användning
;;
;; sigmoid, sigmoid-deriv Sigmoid-kurva och derivata för backpropagation
;;
;; random-matrix, met-vec-mul Grundläggande linalg
;; outer-product; vec-add
;;
;; struct nn Nätverksstruktur, lagrar vikter och bias
;;
;; forward Beräknar prediktion
;;
;; train-step En iteration av backpropagation
;;
;; train Kör många epoker av in och förväntat utdata för
;; att träna modellen
;;
;; predict Använder nätverket på ny data!
;;
;;
;;;;; Viktiga delar
;;
;; * sigmoid mappar alla värden steglöst till intervallet (0,1)
;; * derivatan används i backpropagation för att räkna ut gradienten
;;
;; w1: vikter mellan input och hidden layer (5x2 matris)
;; b1: bias för hidden layer (5-vektor)
;; w2: viktar mellan hidden och output (1x5 matris)
;; b2: bias för output (1-vektor)
;;
;; Forward pass
;;
;; 1. Beräkna aktivering i hidden layer
;; z1 = W1 * input + b1
;; h = rho z1
;; 2. Beräkna output
;; z2 = W2 * h +b2
;; output = rho(z2)
;;
;; Backpropagation (uppdatering av viktningen)
;;
;; Hjärtat i träningen av ett neuralt nät. Algorimen är "gradient descent" med batch-
;; storlek 1.
;;
;; 1. Forward pass hidden → output
;; 2. Output-felet
;; delta = (output - target) X rho' (output)
;; 3. Hidden-felet
;; delta hidden = (W2/T * delta out) X rho' (hidden)
;; 4. Uppdatera vikternas gradienter
;; W2 ← W2 - nabla * delta out * h^T
;; W1 ← W1 - nabla * delta hidden * input^T
;; 5. Bias uppdateras på samma sätt (jo det är en genväg)
;;

(require math/base)

;; ========================================
;; Aktiveringsfunktioner
;; ========================================
(define (sigmoid x)
(/ 1.0 (+ 1.0 (exp (- x)))))

(define (sigmoid-deriv y) ; y måste redan vara sigmoid(x)
(* y (- 1.0 y)))

;; ========================================
;; Matris-/vektorhjälp (enkel version)
;; ========================================
(define (random-matrix rows cols)
(build-vector rows
(λ (_) (build-vector cols (λ (_) (- (* 2.0 (random)) 1.0))))))

(define (vec-add v1 v2) ; elementvis addition av två vektorer
(build-vector (vector-length v1)
(λ (i) (+ (vector-ref v1 i) (vector-ref v2 i)))))

(define (scalar-mul s v)
(build-vector (vector-length v) (λ (i) (* s (vector-ref v i)))))

(define (outer-product v1 v2) ; v1 kolumn × v2 rad → matris
(build-vector (vector-length v1)
(λ (i)
(build-vector (vector-length v2)
(λ (j) (* (vector-ref v1 i) (vector-ref v2 j)))))))

(define (mat-vec-mul M v) ; M (rows×cols) × v (cols)
(build-vector (vector-length M)
(λ (i)
(for/sum ([j (in-range (vector-length v))])
(* (vector-ref (vector-ref M i) j)
(vector-ref v j))))))

(define (transpose M)
(build-vector (vector-length (vector-ref M 0))
(λ (j)
(build-vector (vector-length M)
(λ (i) (vector-ref (vector-ref M i) j))))))

;; ========================================
;; Neuralt nätverk
;; ========================================
(struct nn (w1 b1 w2 b2) #:transparent)

(define (make-nn in-size hidden-size out-size)
(nn (random-matrix hidden-size in-size)
(make-vector hidden-size 0.0)
(random-matrix out-size hidden-size)
(make-vector out-size 0.0)))

(define (forward net input) ; input är en vektor t.ex. #(0 0)
(let* ([z1 (vec-add (mat-vec-mul (nn-w1 net) input)
(nn-b1 net))]
[h (build-vector (vector-length z1) (λ (i) (sigmoid (vector-ref z1 i))))]
[z2 (vec-add (mat-vec-mul (nn-w2 net) h)
(nn-b2 net))]
[o (build-vector (vector-length z2) (λ (i) (sigmoid (vector-ref z2 i))))])
(values o h)))

(define (train-step net input target lr)
(let-values ([(output hidden) (forward net input)])
(let* ([out-err (build-vector (vector-length output)
(λ (i) (- (vector-ref output i)
(vector-ref target i))))]
[out-delta (build-vector (vector-length output)
(λ (i) (* (vector-ref out-err i)
(sigmoid-deriv (vector-ref output i)))))]

[hidden-err (mat-vec-mul (transpose (nn-w2 net)) out-delta)]
[hidden-delta (build-vector (vector-length hidden)
(λ (i) (* (vector-ref hidden-err i)
(sigmoid-deriv (vector-ref hidden i)))))]

;; Uppdateringar
[dw2 (outer-product out-delta hidden)]
[new-w2 (build-vector (vector-length (nn-w2 net))
(λ (i)
(build-vector (vector-length (vector-ref (nn-w2 net) i))
(λ (j) (- (vector-ref (vector-ref (nn-w2 net) i) j)
(* lr (vector-ref (vector-ref dw2 i) j)))))))]
[new-b2 (build-vector (vector-length (nn-b2 net))
(λ (i) (- (vector-ref (nn-b2 net) i)
(* lr (vector-ref out-delta i)))))]

[dw1 (outer-product hidden-delta input)]
[new-w1 (build-vector (vector-length (nn-w1 net))
(λ (i)
(build-vector (vector-length (vector-ref (nn-w1 net) i))
(λ (j) (- (vector-ref (vector-ref (nn-w1 net) i) j)
(* lr (vector-ref (vector-ref dw1 i) j)))))))]
[new-b1 (build-vector (vector-length (nn-b1 net))
(λ (i) (- (vector-ref (nn-b1 net) i)
(* lr (vector-ref hidden-delta i)))))])

(nn new-w1 new-b1 new-w2 new-b2))))

;; ========================================
;; Skriv ut vikter och bias – snygg tabell (fixad version)
;; ========================================
(define (print-nn net)
(printf "\n=== NEURALT NÄTVERK - VIKTER OCH BIAS ===\n\n")

;; Hjälpfunktion för att formatera tal snyggt (med minustecken på rätt plats)
(define (fmt x)
(~r x
#:min-width 10
#:precision '(= 4)
#:sign #f)) ; #f = visa minus för negativa, inget tecken för positiva

;; W1: Vikter från input till hidden (5×2)
(printf "W1 (Hidden × Input):\n")
(printf " Input0 Input1\n")
(for ([i (in-range (vector-length (nn-w1 net)))])
(printf "Hidden~a " i)
(for ([j (in-range 2)])
(printf "~a " (fmt (vector-ref (vector-ref (nn-w1 net) i) j))))
(printf "\n"))
(printf "\n")

;; b1: Bias för hidden layer
(printf "b1 (Bias hidden layer):\n")
(for ([i (in-range (vector-length (nn-b1 net)))])
(printf "~a " (fmt (vector-ref (nn-b1 net) i))))
(printf "\n\n")

;; W2: Vikter från hidden till output (1×5)
(printf "W2 (Output × Hidden):\n")
(printf " Hidden0 Hidden1 Hidden2 Hidden3 Hidden4\n")
(printf "Output ")
(for ([j (in-range 5)])
(printf "~a " (fmt (vector-ref (vector-ref (nn-w2 net) 0) j))))
(printf "\n\n")

;; b2: Bias för output
(printf "b2 (Bias output):\n")
(printf "~a\n" (fmt (vector-ref (nn-b2 net) 0)))

(printf "\n========================================\n"))

;; Träna nätverket
(define (train net data epochs lr)
(for ([ep (in-range epochs)])
(for ([sample data])
(set! net (train-step net (car sample) (cadr sample) lr)))

(when (zero? (modulo ep 500)) ; oftare än var 1000:e
(let ([loss (for/sum ([sample data])
(let-values ([(output _) (forward net (car sample))])
(let ([target (vector-ref (cadr sample) 0)]
[pred (vector-ref output 0)])
(sqr (- target pred)))))])
(printf "Epoch ~a Loss: ~a\n" ep (/ loss (length data))))))
(print-nn net)
net)

;; Prediktera
(define (predict net input)
(let-values ([(output _) (forward net input)])
output))

;; ========================================
;; XOR-exempel
;; ========================================
(define xor-data
(list (list #(0 0) #(0))
(list #(0 1) #(1))
(list #(1 0) #(1))
(list #(1 1) #(0))))

(define net (make-nn 2 5 1)) ; 2 input, 5 dolda neuroner, 1 output
(define rounds 8000) ; 2000 är i minsta laget, 5000 eller hellre 8000 är bättre
(define backpr 0.7)
(printf "Tränar XOR-problemet i ~a rundor med backprop styrka ~a\n" rounds backpr)
(set! net (train net xor-data rounds backpr))

(printf "\n=== Testresultat ===\n")
(for ([sample xor-data])
(let ([pred (vector-ref (predict net (car sample)) 0)])
(printf "Input ~a → Förväntat: ~a Predikterat: ~a\n"
(car sample)
(vector-ref (cadr sample) 0)
(if (> pred 0.5) 1.0 0.0))))
</pre>

Racket/Markov

2026-04-24T15:25:02Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

= Markovkedja av 1:a ordningen =

<pre>
#lang racket

;;;;;
;; Markovkedja av förstaordningen
;;
;; Tar en textfil eller stdin och bygger statistik över orden i tre gram
;; därefter producerar den en 150 ord lång text baserad på den statistiken
;;
;; Täpp-Anders Sikvall, anders@sikvall.se, 2026-04-07
;;;;;

(require racket/string
racket/port)

;; ================================================
;; MARKOVKEDJA I RACKET – textinläsning → träning → textgenerering
;; ================================================

;; Bygger en första-ordnings Markovkedja (ord → nästa-ord med vikter)
;; Texten splittas på whitespace. Punktuation behålls som del av orden
;; (vill du ha renare hantering kan du utöka med regexp senare).
(define (bygg-markov text)
(let ([ord-lista (string-split text)])
(define transitions (make-hash))
(for ([i (in-range 0 (sub1 (length ord-lista)))])
(let* ([nuvarande (list-ref ord-lista i)]
[nästa (list-ref ord-lista (add1 i))])
;; Skapa eller hämta inner-hash för nästa ord
(let ([nästa-hash (hash-ref! transitions nuvarande (λ () (make-hash)))])
(hash-update! nästa-hash nästa add1 0))))
transitions))

;; Väljer nästa ord med korrekt viktning (roulette wheel / weighted random)
(define (viktad-slump nästa-hash)
(let* ([par (hash->list nästa-hash)]
[total (apply + (map cdr par))])
(if (zero? total)
#f ; ingen fortsättning finns
(let ([rand-val (random total)])
(let loop ([lst par]
[acc 0])
(let* ([pair (car lst)]
[key (car pair)]
[cnt (cdr pair)])
(if (< rand-val (+ acc cnt))
key
(loop (cdr lst) (+ acc cnt)))))))))

;; Genererar ny text med angivet antal ord
(define (generera-text transitions start-ord antal-ord)
(let loop ([nuvarande start-ord]
[resultat (list start-ord)]
[kvar (sub1 antal-ord)])
(if (<= kvar 0)
(string-join (reverse resultat) " ")
(let* ([nästa-hash (hash-ref transitions nuvarande (make-hash))]
[nästa (viktad-slump nästa-hash)])
(if (not nästa)
(string-join (reverse resultat) " ") ; kedjan tog slut
(loop nästa
(cons nästa resultat)
(sub1 kvar)))))))

;; ================================================
;; HUVUDPROGRAM – läser från stdin och skriver ut genererad text
;; ================================================

(define (main)
(let* ([input-text (port->string (current-input-port))]
[model (bygg-markov input-text)])
(cond
[(hash-empty? model)
(displayln "Fel: Ingen text inläst! Mata in text via stdin eller fil.")]
[else
;; Välj ett slumpmässigt startord bland alla ord som förekommer
(let* ([alla-start-ord (hash-keys model)]
[start-ord (list-ref alla-start-ord (random (length alla-start-ord)))])
(displayln "=== Genererad text (100 ord) ===")
(displayln (generera-text model start-ord 150)))])))

;; Kör programmet direkt när filen exekveras med racket
(main)
</pre>

= Markovkedja av 3:e ordningen =

<pre>
#lang racket

;;;;;
;; Markovkedja av tredje ordningen
;;
;; Tar en textfil eller stdin och bygger statistik över orden i tre gram
;; därefter producerar den en 150 ord lång text baserad på den statistiken
;;
;; Täpp-Anders Sikvall, anders@sikvall.se, 2026-04-07
;;;;;

(require racket/string
racket/port)

;; ================================================
;; MARKOVKEDJA – TREDJE ORDNINGEN (3-gram)
;; ================================================

;; Skapar alla n-gram
(define (make-ngrams words n)
(for/list ([i (in-range 0 (- (length words) (sub1 n)))])
(take (drop words i) n)))

;; Bygger 3:e ordningens Markovmodell – korrekt indexering
(define (build-markov-3 text)
(define words (filter non-empty-string? (string-split text)))
(when (< (length words) 4)
(error 'build-markov-3 "Texten är för kort för 3-gram (minst 4 ord behövs)."))

(define transitions (make-hash))

(for ([i (in-range 0 (- (length words) 3))])
(let* ([prefix (list (list-ref words i)
(list-ref words (+ i 1))
(list-ref words (+ i 2)))]
[next-word (list-ref words (+ i 3))]
[freq-hash (hash-ref! transitions prefix (λ () (make-hash)))])
(hash-update! freq-hash next-word add1 0)))

transitions)

;; Viktad slumpmässig val
(define (weighted-random freq-hash)
(define options (hash->list freq-hash))
(define total (apply + (map cdr options)))
(if (zero? total)
#f
(let ([r (random total)])
(let loop ([lst options] [acc 0])
(match lst
['() #f]
[(cons (cons word count) rest)
(if (< r (+ acc count))
word
(loop rest (+ acc count)))])))))

;; Genererar text
(define (generate-text-3 transitions start-prefix num-words)
(let loop ([current-prefix start-prefix]
[result (vector->list (list->vector start-prefix))] ; enklare append
[remaining (- num-words 3)])
(if (<= remaining 0)
(string-join result " ")
(let* ([freq-hash (hash-ref transitions current-prefix (make-hash))]
[next-word (weighted-random freq-hash)])
(if (not next-word)
(string-join result " ")
(let ([new-prefix (append (cdr current-prefix) (list next-word))])
(loop new-prefix
(append result (list next-word))
(sub1 remaining))))))))

;; ================================================
;; HUVUDPROGRAM
;; ================================================

(define (main)
(let* ([input-text (port->string (current-input-port))]
[words (filter non-empty-string? (string-split input-text))])
(cond
[(< (length words) 4)
(displayln "Fel: Texten är för kort för 3:e ordningens Markovkedja (minst 4 ord behövs).")]
[else
(let* ([model (build-markov-3 input-text)]
[all-prefixes (hash-keys model)]
[start-prefix (list-ref all-prefixes (random (length all-prefixes)))])
(displayln "=== Genererad text med 3:e ordningens Markovkedja (200 ord) ===")
(displayln (generate-text-3 model start-prefix 150)))])))

(main)
</pre>

Racket/Genetic

2026-04-24T15:24:51Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>

#lang racket

;;;;;
;; Genetisk algoritm implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;; ================================================================
;; Genetisk algoritm – Hitta kromosom med:
;; 1. De första 10 bitarna = 1
;; 2. Totalt antal 1:or så nära 50 som möjligt
;; ================================================================

;; --------------------- Parametrar ---------------------
(define population-size 100)
(define chromosome-length 200)
(define generations 5000)
(define mutation-rate 0.01)

;; --------------------- Hjälpfunktioner ---------------------

;; Skapar en slumpmässig kromosom (lista med 0 och 1)
(define (random-chromosome)
(for/list ([_ (in-range chromosome-length)])
(random 2)))

;; Fitness-funktion
;; - 1000 poäng om de första 6 bitarna är alla 1:or
;; - upp till 1000 poäng om antalet 1:or är exakt 50
(define (fitness chrom)
(define prefix-5 (take chrom 5))
(define num-ones (apply + chrom))

(define prefix-bonus (if (andmap (λ (x) (= x 1)) prefix-5) 1000 0))
(define distance (abs (- num-ones 50)))

(+ prefix-bonus (- 1000 distance)))

;; Tournament selection (storlek 5)
(define (select-parent population)
(define tournament-size 5)
(argmax fitness
(for/list ([_ (in-range tournament-size)])
(list-ref population (random (length population))))))

;; Single-point crossover
(define (crossover parent1 parent2)
(define point (add1 (random (sub1 chromosome-length))))
(append (take parent1 point)
(drop parent2 point)))

;; Mutation
(define (mutate chrom)
(for/list ([gene chrom])
(if (< (random) mutation-rate)
(- 1 gene)
gene)))

;; Skapar nästa generation (utan elitism ännu)
(define (next-generation population)
(for/list ([_ (in-range population-size)])
(define p1 (select-parent population))
(define p2 (select-parent population))
(mutate (crossover p1 p2))))

;; --------------------- Huvudalgoritm ---------------------

(define (genetic-algorithm)
(printf "Startar genetisk algoritm...\n")
(printf "Mål: Första 5 bitar = 1 och totalt ~a ettor\n\n" 50)

(define initial-population
(for/list ([_ (in-range population-size)])
(random-chromosome)))

(define (evolve population generation)
(define best (argmax fitness population))
(define best-fitness (fitness best))
(define num-ones (apply + best))
(define prefix-ok? (andmap (λ (x) (= x 1)) (take best 5)))

(printf "Gen ~a | Fitness: ~a | Ettor: ~a | Prefix OK: ~a\n"
(~a generation #:width 4 #:align 'right)
best-fitness
num-ones
(if prefix-ok? "Ja" "Nej"))

(cond
[(= best-fitness 2000)
(printf "\n=== PERFEKT LÖSNING HITTAD! ===\n")
(printf "Generation: ~a\n" generation)
(printf "Kromosom: ~a\n" best)
(printf "Antal ettor: ~a\n" num-ones)]

[(>= generation generations)
(printf "\n=== Max generationer nådda ===\n")
(printf "Bästa lösning:\n")
(printf " Fitness: ~a\n" best-fitness)
(printf " Antal ettor: ~a\n" num-ones)
(printf " Första 10: ~a\n" (take best 10))]

[else
(evolve (next-generation population) (add1 generation))]))

(evolve initial-population 0))

;; --------------------- Kör programmet ---------------------
(genetic-algorithm)

<pre>

Racket/6502-emu

2026-04-24T15:24:25Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;; ================================================
;; Enkel 6502-emulator skriven i Racket
;; ================================================
;; Detta är en grundläggande men fullt fungerande emulator för 6502-processorn.
;; Den hanterar minne (64 KB), register, stack, flaggor och ett grundläggande
;; set av instruktioner. Du kan lätt utöka den med fler opkoder.
;;
;; Instruktioner som stöds i denna version (kan utökas i cpu-step):
;; - $00 BRK (stoppar exekveringen)
;; - $A9 LDA #imm
;; - $8D STA abs
;; - $A2 LDX #imm
;; - $E8 INX
;; - $4C JMP abs
;; - $D0 BNE rel (enkel branch)
;;
;; NYTT: Funktioner för att skriva ut minne och flaggor har lagts till!

(struct cpu (a x y pc sp p mem) #:mutable #:transparent)

;; Flaggor (statusregister P)
(define CARRY #b00000001)
(define ZERO #b00000010)
(define INTERRUPT #b00000100)
(define DECIMAL #b00001000)
(define BREAK #b00010000)
(define OVERFLOW #b01000000)
(define NEGATIVE #b10000000)

;; Skapa en ny CPU (PC startar godtyckligt, SP pekar mot stack-sidan)
(define (make-cpu)
(cpu 0 0 0 #x8000 #xFF #b00100100 (make-vector 65536 0)))

;; Minnesåtkomst
(define (mem-read cpu addr)
(vector-ref (cpu-mem cpu) (bitwise-and addr #xFFFF)))

(define (mem-write cpu addr val)
(vector-set! (cpu-mem cpu) (bitwise-and addr #xFFFF) (bitwise-and val #xFF)))

;; Stack (6502-stack ligger på sidan 0x01)
(define (stack-push cpu val)
(mem-write cpu (cpu-sp cpu) val)
(set-cpu-sp! cpu (bitwise-and #xFF (- (cpu-sp cpu) 1))))

(define (stack-pop cpu)
(set-cpu-sp! cpu (bitwise-and #xFF (+ (cpu-sp cpu) 1)))
(mem-read cpu (cpu-sp cpu)))

;; Uppdatera N- och Z-flaggor (används av de flesta instruktioner)
(define (update-nz cpu val)
(set-flag cpu NEGATIVE (not (zero? (bitwise-and val #x80))))
(set-flag cpu ZERO (zero? (bitwise-and val #xFF))))

(define (set-flag cpu mask val)
(if val
(set-cpu-p! cpu (bitwise-ior (cpu-p cpu) mask))
(set-cpu-p! cpu (bitwise-and (cpu-p cpu) (bitwise-not mask)))))

(define (get-flag cpu mask)
(not (zero? (bitwise-and (cpu-p cpu) mask))))

;; Hjälpfunktioner för att hämta data och öka PC
(define (fetch-byte cpu)
(define addr (cpu-pc cpu))
(set-cpu-pc! cpu (add1 addr))
(mem-read cpu addr))

(define (fetch-word cpu)
(define lo (fetch-byte cpu))
(define hi (fetch-byte cpu))
(bitwise-ior lo (arithmetic-shift hi 8)))

;; Huvudfunktion: exekvera en instruktion
(define (cpu-step cpu)
(define opcode (fetch-byte cpu))
(case opcode
;; BRK – stoppar emulatorn
[(#x00)
(set-flag cpu BREAK #t)
'brk]

;; LDA #imm
[(#xA9)
(define val (fetch-byte cpu))
(set-cpu-a! cpu val)
(update-nz cpu val)]

;; STA abs
[(#x8D)
(define addr (fetch-word cpu))
(mem-write cpu addr (cpu-a cpu))]

;; LDX #imm
[(#xA2)
(define val (fetch-byte cpu))
(set-cpu-x! cpu val)
(update-nz cpu val)]

;; INX
[(#xE8)
(define new-x (bitwise-and #xFF (add1 (cpu-x cpu))))
(set-cpu-x! cpu new-x)
(update-nz cpu new-x)]

;; JMP abs
[(#x4C)
(define addr (fetch-word cpu))
(set-cpu-pc! cpu addr)]

;; BNE rel (branch if not equal / Z=0)
[(#xD0)
(define offset (fetch-byte cpu))
(when (not (get-flag cpu ZERO))
(set-cpu-pc! cpu (+ (cpu-pc cpu)
(if (> offset #x7F) (- offset #x100) offset))))]

[else
(error "Okänt opcode:" (format "~x" opcode))]))

;; Ladda ett program (lista av bytes) till minnet
(define (load-program cpu start-addr program-bytes)
(for ([b program-bytes]
[i (in-naturals)])
(mem-write cpu (+ start-addr i) b)))

;; Kör emulatorn tills BRK eller max-steg nås
(define (run-cpu cpu [max-steps 100000])
(let loop ([steps 0])
(cond
[(>= steps max-steps) 'timeout]
[else
(define result (cpu-step cpu))
(if (eq? result 'brk)
'halted-by-brk
(loop (add1 steps)))])))

;; ================================================
;; NYA HJÄLPFUNKTIONER: Skriv ut minne och flaggor
;; ================================================

;; Skriver ut aktuellt CPU-tillstånd (alla register + flaggor i läsbart format)
(define (print-cpu-state cpu)
(printf "=== CPU STATUS ===~n")
(printf "PC: $~x A: $~x X: $~x Y: $~x SP: $~x~n"
(cpu-pc cpu)
(cpu-a cpu)
(cpu-x cpu)
(cpu-y cpu)
(cpu-sp cpu))
(printf "P: $~x " (cpu-p cpu))
(printf "Flags: [N:~a V:~a - B:~a D:~a I:~a Z:~a C:~a]~n"
(if (get-flag cpu NEGATIVE) "1" "0")
(if (get-flag cpu OVERFLOW) "1" "0")
(if (get-flag cpu BREAK) "1" "0")
(if (get-flag cpu DECIMAL) "1" "0")
(if (get-flag cpu INTERRUPT)"1" "0")
(if (get-flag cpu ZERO) "1" "0")
(if (get-flag cpu CARRY) "1" "0"))
(newline))

;; Hex-dump av ett minnesområde (16 bytes per rad + ASCII-del)
;; Användning: (print-memory my-cpu #x0000 #x00FF) eller bara (print-memory my-cpu #x0600)
(define (print-memory cpu start [end #f])
(when (not end)
(set! end (+ start 255))) ; default: 256 bytes om inget slut anges
(set! start (bitwise-and start #xFFFF))
(set! end (bitwise-and end #xFFFF))
(printf "=== MEMORY DUMP $~4x – $~4x ===~n" start end)
(for ([addr (in-range start (add1 end) 16)])
(when (<= addr end)
(printf "$~4x: " addr)
;; Hex-delen
(for ([i (in-range 16)])
(define a (+ addr i))
(if (<= a end)
(printf "~2x " (mem-read cpu a))
(printf " ")))
;; ASCII-del
(printf " | ")
(for ([i (in-range 16)])
(define a (+ addr i))
(if (<= a end)
(let ([b (mem-read cpu a)])
(printf "~a" (if (and (>= b #x20) (<= b #x7E))
(integer->char b)
".")))
(printf " ")))
(newline)))
(newline))

;; ================================================
;; EXEMPEL: Ett litet program som demonstrerar emulatorn
;; ================================================
;; Programmet gör följande:
;; LDA #$05 ; A = 5
;; STA $0010 ; minne[0x0010] = 5
;; LDX #$0A ; X = 10
;; INX ; X = 11
;; JMP $0610 ; hoppa till en BRK
;; BRK

(define example-program
(list #xA9 #x05 ; LDA #5
#x8D #x10 #x00 ; STA $0010
#xA2 #x0A ; LDX #10
#xE8 ; INX
#x4C #x10 #x06 ; JMP $0610
#x00)) ; BRK (vid 0x0610)

;; Hur du kör exemplet (med de nya utskriftsfunktionerna):

(define my-cpu (make-cpu))
(load-program my-cpu #x0600 example-program)
(print-cpu-state my-cpu)
(set-cpu-pc! my-cpu #x0600)
(print-cpu-state my-cpu)
(run-cpu my-cpu)
(print-cpu-state my-cpu)

;; Flera opkoder kan läggas till för bättre emulering!

</pre>

Racket/Multitråd

2026-04-24T15:24:06Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Multitrådad demo
;; Täpp-Anders Sikvall, anders@sikvall.se, 2006-04-04
;; Racketkurs.

;; Simulerar tidsödande arbete genom att pausa tråden en slumpmässig tid
(define (random-sleep min-sec max-sec)
(sleep (+ min-sec (* (random) (- max-sec min-sec)))))

;; En arbetare körs i en egen tråd och lyssnar på work-channel
(define (start-worker id work-channel result-channel)
(thread
(λ ()
(let loop ()
;; Vänta på att få ett meddelande från arbetskön
(match (channel-get work-channel)
;; Om meddelandet är 'done', avsluta loopen och därmed tråden
['done
(printf "Arbetare ~a: Avslutar.\n" id)]

;; Om meddelandet är ett tal, utför beräkningen
[n
(printf "Arbetare ~a: Bearbetar värde ~a...\n" id n)
(random-sleep 0.1 0.4)

;; Skicka tillbaka resultatet.
;; OBS: Detta blockerar arbetaren tills huvudtråden läser från result-channel.
(channel-put result-channel (list id (* n n)))
(loop)])))))

;; --- Huvudprogram ---

(define (main)
(define num-workers 4)
(define num-tasks 10)

;; Skapa kanaler för kommunikation
;; Dessa är synkrona (blockerande) i Racket
(define work-channel (make-channel))
(define result-channel (make-channel))

(printf "System: Startar ~a arbetstrådar.\n" num-workers)

;; Starta arbetartrådarna och spara deras referenser i en lista
(define workers
(for/list ([i (in-range num-workers)])
(start-worker i work-channel result-channel)))

;; 1. Skicka uppgifter till arbetskön.
;; Vi gör detta i en separat tråd för att säkerställa att huvudtråden
;; kan börja tömma resultat-kanalen omedelbart.
(thread
(λ ()
(for ([task (in-range 1 (add1 num-tasks))])
(channel-put work-channel task))

;; Skicka en 'done'-signal per arbetare för att stänga ner dem snyggt
(for ([_ (in-range num-workers)])
(channel-put work-channel 'done))))

;; Samla in resultaten.
(printf "System: Samlar in resultat.\n")
(for ([_ (in-range num-tasks)])
(match (channel-get result-channel)
[(list id result)
(printf "Resultat: Arbetare ~a levererade ~a\n" id result)]))

;; Vänta på att trådarna faktiskt har stängt ner.
(printf "System: Väntar på att trådar stängs ner...\n")
(for-each thread-wait workers)

(printf "System: Programmet är klart.\n"))

;; Kör programmet
(main)</pre>

Racket/Lille-GUI

2026-04-24T15:23:47Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket/gui

;;;;;
;; Riktigt Enkelt GUI-Demo implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;; Skapa huvudfönstret
(define frame
(new frame%
[label "Racket GUI Demo"]
[width 520]
[height 420]))

;; Meny
(define menu-bar (new menu-bar% [parent frame]))

(define menu-file (new menu% [label "Arkiv"] [parent menu-bar]))
(new menu-item% [label "Öppna..."] [parent menu-file]
[callback (λ (i e) (message-box "Öppna" "Filöppning simulerad"))])
(new menu-item% [label "Spara"] [parent menu-file]
[callback (λ (i e) (message-box "Spara" "Filen sparad!"))])
(new separator-menu-item% [parent menu-file])
(new menu-item% [label "Avsluta"] [parent menu-file]
[callback (λ (i e) (send frame show #f))])

(define menu-help (new menu% [label "Hjälp"] [parent menu-bar]))
(new menu-item% [label "Om programmet"] [parent menu-help]
[callback (λ (i e) (message-box "Om" "Racket GUI Demo\nPedagogisk exempel"))])

;; Lite layouting av dialogen
(define main-panel
(new vertical-panel% [parent frame] [spacing 12] [border 15]))

;; Rubrik
(new message%
[parent main-panel]
[label "Välkommen till Racket GUI-demo!"])

;; Input-fält, 2 st, namn och epost
(define name-field
(new text-field% [parent main-panel] [label "Namn:"] [init-value "Anna Andersson"]))

(define email-field
(new text-field% [parent main-panel] [label "E-post:"] [init-value "anna@example.com"]))

;; Radio buttons för att välja färg
(define color-group
(new group-box-panel% [parent main-panel] [label "Favoritfärg"]))

(define color-radio
(new radio-box% [parent color-group] [label #f]
[choices '("Röd" "Grön" "Blå" "Gul")]
[style '(vertical)]))

;; Knappar för rensa och skicka
(define btn-panel
(new horizontal-panel% [parent main-panel] [alignment '(center center)] [spacing 20]))

(new button% [parent btn-panel] [label "Rensa"]
[callback (λ (b e)
(send name-field set-value "")
(send email-field set-value "")
(send color-radio set-selection 0))])

(new button% [parent btn-panel] [label "Skicka"] [style '(border)]
[callback (λ (b e)
(define name (send name-field get-value))
(define email (send email-field get-value))
(define color (list-ref '("Röd" "Grön" "Blå" "Gul")
(send color-radio get-selection)))
(message-box "Tack!"
(format "Hej ~a!\n\nE-post: ~a\nFavoritfärg: ~a"
name email color)))])

;; Centrera fönstret och starta GUI
(send frame center)
(send frame show #t)

<pre>

Racket/RLE

2026-04-24T15:23:35Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; RLE – Run Length Encoder
;;
;; I/O via stdio <infil >utfil
;;
;; Kodar data genom att räkna antal förekomster av samma tecken/byte i rad och
;; ersätter den med ett cons-par (antal . tecken) tills nästa förekomst finns.
;; Kan operera binärt men med begränsningen av max 255 bytes konsekutivt sedan
;; startas en ny ram.
;;
;; racket rle.rkt [ --encode | --decode | --help ] [ --binary ] < infil > utfil
;;
;; --encode kodar stdin till stdout lisp style om inte --binary används
;; --decode avkodar stdin till stdout lisp style om inte --binary används
;; --binary skriver kodad data binärt, läser binär data för avkodning
;; --help visar en enkel hjälptext
;; --test kör en enkel sån därn JOONIT TÄST di kallart
;;
;; Saker som kan göras bättre:
;;
;; Det finns ganska lite felkontroll och vad du kastar på dekodern kommer den försöka
;; tills det skiter sig.
;;
;; Man kan också tänka sig att använda mer än en byte för antal i binärt mode
;; men också en grej är ju att man aldrig kommer koda för 0 tecken så man kunde
;; ju lika gärna koda för 1-256 i stället för 0-255. Jag har struntat i det.
;;
;;;;;

;; --- Kärnlogik ---

;; Grupperar element
(define (pack-limited lst)
(cond [(empty? lst) '()]
[else
(let-values ([(prefix suffix) (splitf-at lst (lambda (x) (equal? x (first lst))))])
(if (> (length prefix) 255)
;; Om gruppen är för lång, hugg av vid 255 och fortsätt med resten
(cons (take prefix 255) (pack-limited (append (drop prefix 255) suffix)))
;; Annars, fortsätt som vanligt
(cons prefix (pack-limited suffix))))]))

(define (encode lst)
(map (lambda (group) (list (length group) (first group)))
(pack-limited lst)))

(define (decode lst)
(append-map (lambda (entry) (make-list (first entry) (second entry)))
lst))

;; --- Binär I/O ---

(define (write-binary encoded-data)
(for ([pair encoded-data])
(write-byte (first pair))
(write-byte (second pair))))

(define (read-binary)
(let ([count (read-byte)])
(if (eof-object? count)
'()
(let ([val (read-byte)])
(cons (list count val) (read-binary))))))

;; --- Körlägen ---

(define (run-encode binary?)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))])
(if binary?
(write-binary encoded)
(write encoded)))) ; Använd write för att få korrekt läsbar listformat

(define (run-decode binary?)
(let* ([data (if binary? (read-binary) (read))]
[decoded (decode data)])
(display (list->bytes decoded))))

(define (run-test)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))]
[decoded (list->bytes (decode encoded))])
(if (equal? input decoded)
(printf "Test lyckades! (~a bytes in, ~a noder skapade)\n"
(bytes-length input) (length encoded))
(error "Test misslyckades: Datat korrupt!"))))

;; --- CLI ---

(define (show-help)
(displayln "Användning: racket rle.rkt [FLAGGA] < infil > utfil")
(displayln " -e, --encode Koda (standard: text-listor)")
(displayln " -d, --decode Dekoda (standard: text-listor)")
(displayln " -b, --binary Kör i binärläge (1 byte antal, 1 byte värde)")
(displayln " -t, --test Verifiera att koda+dekoda bevarar data")
(displayln " -h, --help Visa denna hjälp"))

(define (main)
(let ([args (vector->list (current-command-line-arguments))])
(cond
[(member "-t" args) (run-test)]
[(and (member "-e" args) (or (member "-b" args) (member "--binary" args))) (run-encode #t)]
[(member "-e" args) (run-encode #f)]
[(and (member "-d" args) (or (member "-b" args) (member "--binary" args))) (run-decode #t)]
[(member "-d" args) (run-decode #f)]
[else (show-help)])))

(main)

</pre>

Racket/Personreg

2026-04-24T15:23:17Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Enkel personinfodatabas implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;; Global lista som håller alla personer, just nu tom
(define personer '())

;; Skapa en person med namngivna parametrar
(define (skapa-person
#:förnamn förnamn
#:efternamn efternamn
#:ålder ålder
#:stad [stad ""] ;Valfria parametrar med defaultvärden
#:telefon [telefon ""])
(define person (list (cons 'förnamn förnamn) ;när man consar par såhär
(cons 'efternamn efternamn) ;måste man använda car/cdr!
(cons 'ålder ålder)
(cons 'stad stad)
(cons 'telefon telefon)))

(set! personer (cons person personer)) ; lägger till en person i listan personer och returnerar
person) ; sedan samma person

;; Sökfunktion (oförändrad)
(define hitta-person
(make-keyword-procedure
(lambda (keywords keyword-values . rest)
(if (empty? keywords)
personer
(filter (λ (person)
(for/and ([kw keywords]
[val keyword-values])
(let ([field-key (string->symbol (keyword->string kw))])
(let ([found (assoc field-key person)])
(and found
(equal? (string-downcase (format "~a" val))
(string-downcase (format "~a" (cdr found)))))))))
personer)))))

;; Pretty-print funktioner
(define (pretty-print-person person)
(printf " Förnamn: ~a\n" (cdr (assoc 'förnamn person))) ;här går det inte använda rest
(printf " Efternamn: ~a\n" (cdr (assoc 'efternamn person))) ;för det är inte en lista, det
(printf " Ålder: ~a\n" (cdr (assoc 'ålder person))) ;är ett consat par (ålder . 34)

(let ([stad (cdr (assoc 'stad person))])
(when (and stad (not (equal? stad "")))
(printf " Stad: ~a\n" stad)))

(let ([telefon (cdr (assoc 'telefon person))])
(when (and telefon (not (equal? telefon "")))
(printf " Telefon: ~a\n" telefon)))

(newline))

(define (pretty-print-persons lst)
(if (empty? lst)
(displayln " Inga personer hittades.")
(for ([p (reverse lst)])
(pretty-print-person p))))

;; Spara och ladda – Lispformat (.dat)
(define data-fil "personer.dat") ;default filnamn

(define (spara-personer [filnamn data-fil]) ;men i anrop kan du ge eget namn
(with-output-to-file filnamn
(λ () (write personer))
#:exists 'replace) ;om filen finns, skriv över den
(printf "* Sparat ~a personer till \"~a\"\n"
(length personer) filnamn))

(define (ladda-personer [filnamn data-fil])
(if (file-exists? filnamn)
(begin
(set! personer (with-input-from-file filnamn read))
(printf "* Laddat ~a personer från \"~a\"\n" (length personer) filnamn))
(printf "! Filen \"~a\" finns inte.\n" filnamn)))

;; Spara och ladda – CSV-format (för enkel redigering)
(require csv-writing csv-reading)
(define csv-fil "personer.csv")

;; Hjälpfunktion: person → CSV-rad
(define (person->csv-row person)
(list (format "~a" (cdr (assoc 'förnamn person)))
(format "~a" (cdr (assoc 'efternamn person)))
(format "~a" (cdr (assoc 'ålder person)))
(format "~a" (cdr (assoc 'stad person)))
(format "~a" (cdr (assoc 'telefon person)))))

;; SPARA till CSV
(define (spara-personer-csv [filnamn csv-fil])
(define rubriker (list (list "Förnamn" "Efternamn" "Ålder" "Stad" "Telefon")))
(define rader (map person->csv-row (reverse personer))) ; reverse så ordningen blir "naturlig"

(with-output-to-file filnamn #:exists 'replace
(λ ()
(display-table rubriker)
(display-table rader)))

(printf "* Sparat ~a personer till CSV-filen \"~a\"\n" (length personer) filnamn))

;; LADDA från CSV
(define (ladda-personer-csv [filnamn csv-fil])
(if (file-exists? filnamn)
(let* ([reader (make-csv-reader (open-input-file filnamn))]
[all-rows (csv->list reader)] ;konvertera från csv till Lisp lista
[data-rows (if (empty? all-rows) '() (rest all-rows))]) ; hoppa över rubrik-rad

(define nya-personer
(for/list ([row data-rows])
(list (cons 'förnamn (list-ref row 0))
(cons 'efternamn (list-ref row 1))
(cons 'ålder (list-ref row 2)) ; behåll som sträng eller konvertera
(cons 'stad (list-ref row 3)) ; med string->number om du vill
(cons 'telefon (list-ref row 4)))))

(set! personer (append nya-personer personer)) ; eller (set! personer nya-personer) om du vill ersätta
(printf "* Laddat ~a personer från CSV-filen \"~a\"\n" (length nya-personer) filnamn))
(printf "! CSV-filen \"~a\" finns inte.\n" filnamn)))

;; SORTERA PERSONER
;; Sorterar först på efternamn över hela listan
;; därefter på efternamn. Då blir det som det ska
(define (sortera-personer)
;; Steg 1: Sortera på förnamn
(set! personer
(sort personer
(λ (p1 p2)
(string-ci<? (cdr (assoc 'förnamn p1)) ;string-ci är "string case insensitive"
(cdr (assoc 'förnamn p2))))))

;; Steg 2: Sortera på efternamn (detta blir den slutgiltiga ordningen)
(set! personer
(sort personer
(λ (p1 p2)
(string-ci<? (cdr (assoc 'efternamn p1))
(cdr (assoc 'efternamn p2))))))

personer) ; returnerar den sorterade listan (bra för kedjad användning)

;; ================================================================
;; Exempel på användning
;; ================================================================

;; Skapa testpersoner, detta behöver vi bara göra en gång för sedan skrivs den till disk och
;; vi behöver därefter bara hämta den vid behov!

(skapa-person #:förnamn "Anna" #:efternamn "Andersson" #:ålder 34 #:stad "Stockholm" #:telefon "070-123 45 67")
(skapa-person #:förnamn "Rickard" #:efternamn "Nilsson" #:ålder 28 #:stad "Kista")
(skapa-person #:förnamn "Enar" #:efternamn "Nilsson" #:ålder "74" #:stad "Färjestaden")
(skapa-person #:förnamn "Anna" #:efternamn "Svensson" #:ålder 45 #:stad "Malmö")
(skapa-person #:förnamn "Johan" #:efternamn "Larsson" #:ålder 31 #:stad "Stockholm")

(sortera-personer)

(spara-personer-csv "personlista.csv")

(displayln "=== Personer efter skapande ===")
(pretty-print-persons (hitta-person))

;; Spara både binärt och CSV
(displayln "\n=== Sparar till disk (både .dat och .csv) ===")
(spara-personer "personlista.dat")
(spara-personer-csv "personlista.csv")

;; Rensa minnet (simulerar omstart)
(set! personer '())
(displayln "\n=== Listan rensad ===")
(pretty-print-persons (hitta-person))

;; Ladda tillbaka
(displayln "\n=== Laddar från Lispdata ===")
(ladda-personer "personlista.dat")
(pretty-print-persons (hitta-person))

(set! personer '()) ; Nolla listan igen

(ladda-personer-csv "personlista.csv")
(displayln "\n=== Personer efter laddning från CSV ===")
(pretty-print-persons (hitta-person))

;; Exempel på sökning efter laddning
(displayln "\n=== Sök efter laddning (förnamn anna) ===")
(pretty-print-persons (hitta-person #:förnamn "anna"))
</pre>

Racket/base24

2026-04-24T15:23:05Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; BASE24 encoder/decoder
;; Täpp-Anders Sikvall, anders@sikvall.se, 2026-04-07
;;
;; USAGE
;; racket base24.rkt --encode < INPUT_FILE > OUTPUT_FILE
;; racket base24.rkt --decode < INPUT_FILE > OUTPUT_FILE
;;
;; COMMENT
;; This does not precede the coded data with any kind of header
;; and the error control and handling is abysmally minimal but
;; it shows the ease of implementing something like this compared
;; to languages like C.
;;
;; EXPLANATION
;; The program treats the entire input as a bignum and then basically
;; converts it to the output by repeated division and looking up the
;; quotient in the BASE24 alphabet. Since the bignum implementation
;; is so efficient in Racket/Scheme this means it will be effective
;; even for moderately large files.
;;
;;

;; BASE24 Alfabet (exkluderar förväxlingsbara tecken)
(define alphabet "BCDFGHJKMPQRTVWXY2346789")
(define base 24)
(define max-col 68)

;; Skapar en map för snabb uppslagning vid avkodning
(define char-to-val
(for/hash ([c (in-string alphabet)]
[i (in-naturals)])
(values c i)))

;; Hjälpfunktion för att skriva ut med radbrytningar
(define (display-with-breaks str)
(let loop ([remaining str])
(cond
[(<= (string-length remaining) max-col)
(displayln remaining)]
[else
(displayln (substring remaining 0 max-col))
(loop (substring remaining max-col))])))

;; --- ENCODER ---
(define (encode)
(let* ([input-bytes (port->bytes (current-input-port))]
[num (bytes->integer input-bytes)])
(if (zero? num)
(displayln (string-ref alphabet 0))
(let loop ([n num] [res '()])
(if (zero? n)
(display-with-breaks (list->string res))
(loop (quotient n base)
(cons (string-ref alphabet (remainder n base)) res)))))))

;; --- DECODER ---
(define (decode)
;; Vi rensar bort eventuella radbrytningar/whitespaces innan vi avkodar
(let* ([raw-input (port->string (current-input-port))]
[input-str (regexp-replace* #px"\\s+" raw-input "")]
[num (for/fold ([n 0])
([char (in-string input-str)])
(+ (* n base) (hash-ref char-to-val char)))])
(display (integer->bytes num))))

;; --- KONVERTERINGSFUNKTIONER ---
(define (bytes->integer b)
(for/fold ([n 0])
([byte (in-bytes b)])
(+ (arithmetic-shift n 8) byte)))

(define (integer->bytes n)
(if (zero? n)
(bytes 0)
(let loop ([i n] [res '()])
(if (zero? i)
(list->bytes res)
(loop (arithmetic-shift i -8)
(cons (bitwise-and i #xFF) res))))))

;; --- CLI HANTERING ---
(define (main)
(match (current-command-line-arguments)
[(vector (or "--encode" "-e")) (encode)]
[(vector (or "--decode" "-d")) (decode)]
[_ (displayln "Användning: racket base24.rkt [--encode | --decode]")]))

(main)
</pre>

Racket/Hexdump

2026-04-24T15:22:55Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Hexdump implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SYNOPSIS
;; racket hexdump.rkt [ OPTIONS ] filename
;;
;; OPTIONS
;; -h Gives a short help text to the utility
;; --bytes-per-line, -n Determines how many bytes are decoded per line (default 16)
;; --hex, -x Show only hex dump
;; --ascii, -a Show only ASCII dump

(require racket/cmdline)

(define (hexdump-file filename
#:only-hex? [only-hex? #f]
#:only-ascii? [only-ascii? #f]
#:bytes-per-line [n 16])
(printf "Läser fil: ~a (~a bytes)\n\n" filename (file-size filename))
(call-with-input-file filename
(λ (in)
(let loop ([offset 0])
(define chunk (read-bytes n in))
(cond
[(eof-object? chunk) (void)]
[(bytes? chunk)
(define len (bytes-length chunk))
(printf "~a " (~r offset #:base 16 #:min-width 8 #:pad-string "0"))

(define show-both? (not (xor only-hex? only-ascii?)))

(cond
[(and only-hex? (not show-both?))
(for ([i (in-range n)])
(printf "~a " (if (< i len)
(~r (bytes-ref chunk i) #:base 16 #:min-width 2 #:pad-string "0")
" "))
(when (and (= (modulo (add1 i) 8) 0) (= b 32) (<= b 126)) (integer->char b) ".")))
(for ([_ (in-range (- n len))]) (display " "))
(display "|\n")]

[else ; båda eller ingen flagga
(for ([i (in-range n)])
(printf "~a " (if (< i len)
(~r (bytes-ref chunk i) #:base 16 #:min-width 2 #:pad-string "0")
" "))
(when (and (= (modulo (add1 i) 8) 0) (= b 32) (<= b 126)) (integer->char b) ".")))
(for ([_ (in-range (- n len))]) (display " "))
(display "|\n")])

(loop (+ offset n))])))))

(define-values (filename only-hex? only-ascii? bytes-per-line)
(let ([only-hex? #f] [only-ascii? #f] [bytes-per-line 16])
(command-line
#:program "hexdump"
#:usage-help "Användning: racket hexdump.rkt [alternativ] <fil>"
#:once-each
[("-x" "--hex") "Visa endast hex-delen" (set! only-hex? #t)]
[("-a" "--ascii") "Visa endast ASCII-delen" (set! only-ascii? #t)]
[("-n" "--bytes-per-line") n
"Antal bytes per rad (standard: 16)" (let ([num (string->number n)]) (when num (set! bytes-per-line num)))]
#:args (filename)
(values filename only-hex? only-ascii? bytes-per-line))))

(if (not (file-exists? filename))
(printf "Fel: Filen \"~a\" finns inte.\n" filename)
(hexdump-file filename
#:only-hex? only-hex?
#:only-ascii? only-ascii?
#:bytes-per-line bytes-per-line))
</pre>

Racket/Erastothenes

2026-04-24T15:22:44Z

Anders:

[[category:Algoritmer]]
[[category:Programmering]]
[[category:Racket]]

<pre>
#lang racket

;;;;;
;; Erastothenes såll implementerad i Racket
;; Täpp-Anders Sikvall 2026-04-03 anders@sikvall.se
;;;;;

;; Skapar en vektor där indexet motsvarar talet.
;; Om (vector-ref v n) är #t, så är n ett primtal.

(define (make-sieve limit)
(define sieve (make-vector (add1 limit) #t))

;; 0 och 1 är aldrig primtal
(when (>= limit 0) (vector-set! sieve 0 #f))
(when (>= limit 1) (vector-set! sieve 1 #f))

;; Vi behöver bara gå upp till kvadratroten av limit
(for ([p (in-range 2 (add1 (integer-sqrt limit)))])
(when (vector-ref sieve p)
;; Markera alla multiplar av p som falska (starta vid p*p)
(for ([multiple (in-range (* p p) (add1 limit) p)])
(vector-set! sieve multiple #f))))
sieve)

;; Returnerar en lista med alla primtal mellan start och stop
(define (primes-between start stop)
(if (> start stop)
'() ;Returnerar tomt om start > stop
(let ([is-prime? (make-sieve stop)])
(for/list ([n (in-range (max start 2) (add1 stop))]
#:when (vector-ref is-prime? n))
n))))

;; Testkörning
(primes-between 10 50)

</pre>

Racket

2026-04-24T15:21:24Z

Anders:

Racket är ett programmeringsspråk i Lispfamiljen och underfamilj till Scheme. Det är kompatibelt med Scheme R5RS och andra varianter men har också ett eget väl utbyggt bibliotek av funktioner och rutiner och kanske en av de enklaste språken att komma igång och skapa GUI-applikationer i.

= Installation Ubuntu =

<pre>
sudo add-apt-repository ppa:plt/racket -y
sudo apt update
sudo apt install racket
</pre>

Kör igång det inbyggda IDE:t med "drracket" antingen från applikationsmenyn eller terminalen.

= Kodexempel (Sommarhack 2026) =

# [[Racket/Erastothenes]]
# [[Racket/Hexdump]]
# [[Racket/base24]]
# [[Racket/Personreg]]
# [[Racket/RLE]]
# [[Racket/Lille-GUI]]
# [[Racket/Multitråd]]
# [[Racket/6502-emu]]
# [[Racket/Genetic]]
# [[Racket/Markov]]
# [[Racket/Neural]]
# [[Racket/Posits]]
# [[Racket/3D-boll]] -- från Olme

[[category:Racket]]
[[category:Programmering]]
[[category:Algoritmer]]
[[category:Förgreningssida]]

Fisher-Yates Shuffle

2026-04-24T15:19:35Z

Anders:

== Bakgrund ==

Fisher-Yates är en algoritm som används för att slumpmässigt omfördela innehållet i en grupp på ett sätt som fungerar ungefär som när man blandar en kortlek. Det ger minsta möjliga bias även om pseudoslumptalskällan inte är välfiltrerad och ren.

Sättet som algoritmen arbetar på fungerar ungefär som när man plockar lotter ur en tombola eller blandar en kortlek där man drar en efter en tills det inte längre finns några att dra. Rätt använd är biasen väldigt låg.

Andra namn är också ''the Knuth Shuffle'' efter matematikern Donald E. Knuth som använder denna.

== Funktion ==

Som ett exempel skall vi permutera numren 1 till 8 genom att använda Fisher-Yates metod. Vi skriver talen på en bit papper:

{| class="wikitable"
|-
! Range !! Roll !! Scratch !! Result
|-
|   ||   || 1 2 3 4 5 6 7 8 ||  
|}

Nu slumpar vi ett tal ''k'' mellan 1-8, vi kan säga att det blev 3 så vi stryker det 3:e numret från papperet och flyttar det till resultatrutan.

{| class="wikitable"
|-
! Range !! Roll !! Scratch !! Result
|-
| 1–8 || 3 || 1 2 <s>3</s> 4 5 6 7 8 || 3
|}

Vi tar ett nytt slumpmässigt tal, denna gång från 1-7 som matchar de siffror vi ej har strukit. Låt oss säga att det blev 4, så vi stryker det fjärde ej redan strukna numret och flyttar det till resultatrutan.

{| class="wikitable"
|-
! Range !! Roll !! Scratch !! Result
|-
| 1–7 || 4 || 1 2 <s>3<</s> 4 <s>5</s> 6 7 8 || 3 5
|}

Vi fortsätter på samma vis med ett nytt slumptal, denna gång från 1-6 och sedan 1-5 osv ända tills alla tal är strukna.

{| class="wikitable"
|-
! Range !! Roll !! Scratch !! Result
|-
| 1-6 || 5 || 1 2 <s>3</s> 4 <s>5</s> 6 <s>7</s> 8 || 3 5 7
|-
| 1-5 || 3 || 1 2 <s>3</s> <s>4</s> <s>5</s> 6 <s>7</s> 8 || 3 5 7 4
|-
| 1-4 || 4 || 1 2 <s>3</s> <s>4</s> <s>5</s> 6 <s>7</s> <s>8</s> || 3 5 7 4 8
|-
| 1-3 || 1 || <s>1</s> 2 <s>3</s> <s>4</s> <s>5</s> 6 <s>7</s> <s>8</s> || 3 5 7 4 8 1
|-
| 1-2 || 2 || <s>1</s> 2 <s>3</s> <s>4</s> <s>5</s> <s>6</s> <s>7</s> <s>8</s> || 3 5 7 4 8 1 6
|-
|   ||   || <s>1</s> <s>2</s> <s>3</s> <s>4</s> <s>5</s> <s>6</s> <s>7</s> <s>8</s> || 3 5 7 4 8 1 6 2
|}

För att spara tid kan man byta plats med alla strukna tal och det sista talet i serien och därmed hela tiden ha en sammanhängande ordning med ostrukna tal. Se pseudokoden nedan som gör på det sättet.

= Implementation =

== Pseudokod ==

Randomisera n element på plats i en array

for i from n-1 down to 1 do
j = random(0..i)
swap a[j], a[i]
done

Initialisera en array a med n elements från en slumpmässigt ordnad kopia av source

a[0] = source[0]
for i from 1 to n-1 do
j = random(0..i)
a[i] = a[j]
a[j] = source[i]
done

== C ==

<pre>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

void fyshuffle(int *array, size_t n)
{
size_t i, j; // Elements in array to swap
int temp; // Temp store

// Set the random generator using current time
srand((unsigned int)time(NULL));
for (i = n - 1; i > 0; i--) {
j = rand() % (i + 1);
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}

int main(int argc, char *argv[]) {
int array[15] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int i;

fyshuffle(array, 15);

for (i = 0; i < 15; i++) {
printf("%d ", array[i]);
}
printf("\n");
}

</pre>

[[category:Programmering]]
[[category:Algoritmer]]
[[category:c]]

Base64

2026-04-24T15:18:44Z

Anders:

{{ofärdig}}

[[category:c]]
[[category:programmering]]
[[category:algoritmer]]

== Bakgrund ==

Tidigare system använde Unix-to-Unix Encoding (UUE) för att koda information på ett sätt att det gick att skicka genom en 7 bitars överföringskanal. Detta system är sedan länge övergivet i moderna datorsystem och i stället använder man Base64 som är en mer effektiv metod.

I korthet går det ut på att man tar in den data som skall kodas, delar upp det i symboler om 6 bitar och därefter kodar dem enligt ''Standardtabellen'' eller någon annan variant. Standardtabellen skall användas för all extern kommunikation eftersom det annars blir inkompatibelt mellan sändare och mottagare.

Se även [[Base32]].

== Procedur ==

Indatat ses som en ström oktetter. Dessa grupperas om 3, dvs i 24 bitar och delas sedan i 6-bitarstal så att det blir 4 stycken 6-bitarsgrupper. Varje sexbitarsgrupp har då ett värde som svarar mot en kod i tabellen och denna kod skickas i stället för 6-bitsgruppen. Om den sista gruppen inte är 3 bytes utan 2 eller 1 motsvarar det bara 2-3 siffror i Base64.

Base64 har fått sitt namn från att 26=64, nämligen antalet symboler i listan som kan skickas.

Kodningen är baserad på följande:
* A-Z motsvarar 0-25
* a-z motsvarar 26-51
* 0-9 motsvarar 52-61
* '+' eller '-' motsvarar 62
* '/' eller '_' motsvarar 63

Anledningen till de två sista är ekvivalenta är för att det ibland kan vara så att vissa system använder endera som signaleringstecken eller liknande och då är det bättre att koda med det andra tecknet i stället. Man måste dock acceptera alla varianter som mottagare men kan välja hur man kodar som sändare. Observera att man EJ bör byta tecken inom samma block.

== Effektiviteten ==
Effektiviteten av kodningen är 3/4. Det betyder att för 24 bitar in produceras 32 bitar ut och det innebär att man därmed får en effektivitetssiffra på 0,75 vilket är ganska bra. Det är precis samma som för UUENCODE.

== Standardtabellen ==
{| border="1" cellpadding="2" cellspacing="0"
|-
! Värde
! Siffra
|rowspan=17| 
! Värde
! Siffra
|rowspan=17| 
! Värde
! Siffra
|rowspan=17| 
! Värde
! Siffra
|-
| 0 || A || 16 || Q || 32 || g || 48 || w
|-
| 1 || B || 17 || R || 33 || h || 49 || x
|-
| 2 || C || 18 || S || 34 || i || 50 || y
|-
| 3 || D || 19 || T || 35 || j || 51 || z
|-
| 4 || E || 20 || U || 36 || k || 52 || 0
|-
| 5 || F || 21 || V || 37 || l || 53 || 1
|-
| 6 || G || 22 || W || 38 || m || 54 || 2
|-
| 7 || H || 23 || X || 39 || n || 55 || 3
|-
| 8 || I || 24 || Y || 40 || o || 56 || 4
|-
| 9 || J || 25 || Z || 41 || p || 57 || 5
|-
|10 || K || 26 || a || 42 || q || 58 || 6
|-
|11 || L || 27 || b || 43 || r || 59 || 7
|-
|12 || M || 28 || c || 44 || s || 60 || 8
|-
|13 || N || 29 || d || 45 || t || 61 || 9
|-
|14 || O || 30 || e || 46 || u || 62 || + -
|-
|15 || P || 31 || f || 47 || v || 63 || / _
|}

Exempel:
{|class="wikitable"
|-
!scope="row"| Text
|colspan="8" align="center"| '''M'''
|colspan="8" align="center"| '''a'''
|colspan="8" align="center"| '''n'''
|-
!scope="row"| ASCII-värden
|colspan="8" align="center"| 77
|colspan="8" align="center"| 97
|colspan="8" align="center"| 110
|-
!scope="row"| Bitmönster
|0||1||0||0||1||1||0||1||0||1||1||0||0||0||0||1||0||1||1||0||1||1||1||0
|-
!scope="row"| Värde per 6 bitar
|colspan="6" align="center"| 19
|colspan="6" align="center"| 22
|colspan="6" align="center"| 5
|colspan="6" align="center"| 46
|-
!scope="row"| Base64-kodat
|colspan="6" align="center"| '''T'''
|colspan="6" align="center"| '''W'''
|colspan="6" align="center"| '''F'''
|colspan="6" align="center"| '''u'''
|}

= Implementationsexempel =

== C ==

<pre>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// BASE64 kodningstabell
static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Funktion för BASE64 kodning (från tidigare)
char* base64_encode(const unsigned char* input, size_t length) {
size_t output_length = 4 * ((length + 2) / 3);
char* encoded = malloc(output_length + 1);

if (encoded == NULL) return NULL;

size_t i, j;
for (i = 0, j = 0; i < length;) {
unsigned int octet_a = i < length ? input[i++] : 0;
unsigned int octet_b = i < length ? input[i++] : 0;
unsigned int octet_c = i < length ? input[i++] : 0;

unsigned int triple = (octet_a << 16) + (octet_b << 8) + octet_c;

encoded[j++] = base64_table[(triple >> 18) & 0x3F];
encoded[j++] = base64_table[(triple >> 12) & 0x3F];
encoded[j++] = base64_table[(triple >> 6) & 0x3F];
encoded[j++] = base64_table[triple & 0x3F];
}

switch (length % 3) {
case 1:
encoded[j - 2] = '=';
encoded[j - 1] = '=';
break;
case 2:
encoded[j - 1] = '=';
break;
}

encoded[output_length] = '\0';
return encoded;
}

// Funktion för BASE64 avkodning
unsigned char* base64_decode(const char* input, size_t* output_length) {
size_t input_length = strlen(input);
if (input_length % 4 != 0) return NULL; // Ogiltig BASE64-längd

// Beräkna utdatalängd
*output_length = input_length / 4 * 3;
if (input[input_length - 1] == '=') (*output_length)--;
if (input[input_length - 2] == '=') (*output_length)--;

unsigned char* decoded = malloc(*output_length);
if (decoded == NULL) return NULL;

// Skapa lookup-tabell för snabbare avkodning
unsigned char decode_table[256] = {0};
for (int i = 0; i < 64; i++) {
decode_table[(unsigned char)base64_table[i]] = i;
}

// Avkoda 4 tecken åt gången till 3 bytes
for (size_t i = 0, j = 0; i < input_length;) {
unsigned int sextet_a = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
i++;
unsigned int sextet_b = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
i++;
unsigned int sextet_c = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
i++;
unsigned int sextet_d = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
i++;

unsigned int triple = (sextet_a << 18) + (sextet_b << 12) +
(sextet_c << 6) + sextet_d;

if (j < *output_length) decoded[j++] = (triple >> 16) & 0xFF;
if (j < *output_length) decoded[j++] = (triple >> 8) & 0xFF;
if (j < *output_length) decoded[j++] = triple & 0xFF;
}

return decoded;
}

// Testprogram
int main() {
const char* original = "Hello World!";
size_t input_length = strlen(original);

// Kodning
char* encoded = base64_encode((const unsigned char*)original, input_length);
if (!encoded) {
printf("Kodningsfel\n");
return 1;
}

// Avkodning
size_t decoded_length;
unsigned char* decoded = base64_decode(encoded, &decoded_length);
if (!decoded) {
printf("Avkodningsfel\n");
free(encoded);
return 1;
}

// Skriv ut resultat
printf("Original: %s\n", original);
printf("Encoded: %s\n", encoded);
printf("Decoded: %.*s\n", (int)decoded_length, decoded);

// Frigör minne
free(encoded);
free(decoded);

return 0;
}
</pre>

[[category:Formatspecifikation]]
[[category:Telekommunikation]]
[[category:Data]]

Base32

2026-04-24T15:18:21Z

Anders:

[[category:c]]
[[category:programmering]]
[[category:algoritmer]]

För bakgrundsinformation se [[Base64]].

= Implementation =

= C =

<pre>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// BASE32 kodningstabell
static const char base32_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

// Funktion för BASE32 kodning
char* base32_encode(const unsigned char* input, size_t length) {
// Beräkna utdatalängd: 8 tecken för varje 5 bytes
size_t output_length = 8 * ((length + 4) / 5);
char* encoded = malloc(output_length + 1);
if (encoded == NULL) return NULL;

size_t i = 0, j = 0;
unsigned long buffer = 0;
int bits_left = 0;

while (i < length || bits_left > 0) {
// Fyll buffert med upp till 5 bytes
if (bits_left < 5 && i < length) {
buffer = (buffer << 8) | input[i++];
bits_left += 8;
}

// Om vi har minst 5 bitar, ta ut ett BASE32-tecken
if (bits_left >= 5) {
int value = (buffer >> (bits_left - 5)) & 0x1F;
encoded[j++] = base32_table[value];
bits_left -= 5;
} else if (i >= length) {
// Padding för sista gruppen
encoded[j++] = '=';
bits_left = 0;
}
}

// Fyll på med padding till multipel av 8
while (j % 8 != 0) {
encoded[j++] = '=';
}

encoded[j] = '\0';
return encoded;
}

// Funktion för BASE32 avkodning
unsigned char* base32_decode(const char* input, size_t* output_length) {
size_t input_length = strlen(input);
if (input_length % 8 != 0) return NULL; // BASE32 måste vara multipler av 8

// Räkna faktiska databytes (exkludera padding)
size_t padding = 0;
for (int i = input_length - 1; i >= 0 && input[i] == '='; i--) {
padding++;
}

// Beräkna utdatalängd
*output_length = (input_length * 5) / 8 - padding;
unsigned char* decoded = malloc(*output_length);
if (decoded == NULL) return NULL;

// Skapa lookup-tabell
unsigned char decode_table[256] = {0};
for (int i = 0; i < 32; i++) {
decode_table[(unsigned char)base32_table[i]] = i;
}

unsigned long buffer = 0;
int bits_left = 0;
size_t j = 0;

for (size_t i = 0; i < input_length; i++) {
if (input[i] == '=') break;

buffer = (buffer << 5) | decode_table[(unsigned char)input[i]];
bits_left += 5;

if (bits_left >= 8) {
decoded[j++] = (buffer >> (bits_left - 8)) & 0xFF;
bits_left -= 8;
}
}

return decoded;
}

// Testprogram
int main() {
const char* original = "Hello World!";
size_t input_length = strlen(original);

// Kodning
char* encoded = base32_encode((const unsigned char*)original, input_length);
if (!encoded) {
printf("Kodningsfel\n");
return 1;
}

// Avkodning
size_t decoded_length;
unsigned char* decoded = base32_decode(encoded, &decoded_length);
if (!decoded) {
printf("Avkodningsfel\n");
free(encoded);
return 1;
}

// Skriv ut resultat
printf("Original: %s\n", original);
printf("BASE32: %s\n", encoded);
printf("Decoded: %.*s\n", (int)decoded_length, decoded);

// Frigör minne
free(encoded);
free(decoded);

return 0;
}
</pre>

Base24

2026-04-24T14:36:54Z

Anders:

[[category:c]]
[[category:programmering]]
[[category:algoritmer]]

= Bakgrund =

Base24 är inte en standardkodning och den är lite mer komplex än de som baseras på ett jämt antal oktetter som [[base32]] samt [[base64]] men det har en fördel också, vi använder bara stora bokstäver A-X.

= Implementation =
<pre>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

const char ALPHABET[] = "BCDFGHJKMNPQRTVWXY2346789";
#define BASE 24
#define MAX_LINE 70
#define CHARS_PER_BLOCK 6 // 6 tecken för data täcker 24 bitar (24^6 > 2^24)

int get_index(char c) {
for (int i = 0; i < BASE; i++) if (ALPHABET[i] == c) return i;
return -1;
}

void encode_block(const uint8_t *in, int len, char *out_buf) {
uint32_t val = 0;
// Packa indata till en 24-bitars integer
if (len >= 1) val |= ((uint32_t)in[0] << 16);
if (len >= 2) val |= ((uint32_t)in[1] << 8);
if (len >= 3) val |= ((uint32_t)in[2]);

out_buf[0] = ALPHABET[len]; // Header: längd

// Konvertera val till bas 24 över 6 tecken (position 1 till 6)
uint32_t temp = val;
for (int i = CHARS_PER_BLOCK; i >= 1; i--) {
out_buf[i] = ALPHABET[temp % BASE];
temp /= BASE;
}
}

int decode_block(const char *in_buf, uint8_t *out_three) {
int len = get_index(in_buf[0]);
if (len < 0 || len > 3) return -1;

uint32_t val = 0;
for (int i = 1; i <= CHARS_PER_BLOCK; i++) {
int idx = get_index(in_buf[i]);
if (idx == -1) return -1;
// Vi bygger värdet baserat på positionell vikt
val = val * BASE + idx;
}

if (len >= 1) out_three[0] = (uint8_t)((val >> 16) & 0xFF);
if (len >= 2) out_three[1] = (uint8_t)((val >> 8) & 0xFF);
if (len >= 3) out_three[2] = (uint8_t)(val & 0xFF);

return len;
}

void encode_stream() {
printf("--- BEGIN BASE24 ENCODED DATA ---\n");
uint8_t in[3];
char out[CHARS_PER_BLOCK + 1];
int bytes_read, line_pos = 0;
while ((bytes_read = fread(in, 1, 3, stdin)) > 0) {
encode_block(in, bytes_read, out);
for (int i = 0; i < CHARS_PER_BLOCK + 1; i++) {
putchar(out[i]);
if (++line_pos >= MAX_LINE) {
putchar('\n');
line_pos = 0;
}
}
}
if (line_pos > 0) putchar('\n');
printf("--- END BASE24 ENCODED DATA ---\n");
}

void decode_stream() {
int ch, count = 0;
char block[CHARS_PER_BLOCK + 1];
uint8_t out[3];

while ((ch = getchar()) != EOF) {
if (ch == '-' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {
if (ch == '-') while ((ch = getchar()) != '\n' && ch != EOF);
continue;
}
block[count++] = (char)ch;
if (count == CHARS_PER_BLOCK + 1) {
int decoded = decode_block(block, out);
if (decoded > 0) fwrite(out, 1, decoded, stdout);
count = 0;
}
}
}

void run_test_case(const char *name, uint8_t *orig, int len) {
printf("Testar: %s (%d bytes)\n", name, len);

int num_blocks = (len + 2) / 3;
char *encoded = malloc(num_blocks * (CHARS_PER_BLOCK + 1));
for (int i = 0; i < num_blocks; i++) {
int chunk = (len - i * 3 > 3) ? 3 : (len - i * 3);
encode_block(&orig[i * 3], chunk, &encoded[i * (CHARS_PER_BLOCK + 1)]);
}

uint8_t *reconstructed = malloc(num_blocks * 3);
int total_decoded = 0;
for (int i = 0; i < num_blocks; i++) {
int res = decode_block(&encoded[i * (CHARS_PER_BLOCK + 1)], &reconstructed[total_decoded]);
if (res > 0) total_decoded += res;
}

if (total_decoded == len && memcmp(orig, reconstructed, len) == 0) {
printf(" [PASS] Data matchar perfekt.\n");
} else {
printf(" [FAIL] Korruption! Längd: %d/%d\n", total_decoded, len);
}

free(encoded);
free(reconstructed);
}

void run_tests() {
printf("BASE24 SJÄLVTEST - FINAL VERSION\n================================\n");
uint8_t test1[13];
for(int i=0; i<13; i++) test1[i] = (uint8_t)(rand() % 256);
run_test_case("13 bytes slumpdata (inkl. höga bitvärden)", test1, 13);

uint8_t test2[12] = {0};
run_test_case("12 bytes nollor", test2, 12);

uint8_t test3[] = "Klockrent, Täpp-Anders!";
run_test_case("Sträng med UTF-8", test3, strlen((char*)test3));
}

int main(int argc, char *argv[]) {
if (argc < 2) return 1;
if (strcmp(argv[1], "--test") == 0) run_tests();
else if (strcmp(argv[1], "--encode") == 0 || strcmp(argv[1], "-e") == 0) encode_stream();
else if (strcmp(argv[1], "--decode") == 0 || strcmp(argv[1], "-d") == 0) decode_stream();
return 0;
}
</pre>

Base24

2026-04-24T14:36:34Z

Anders:

[[category:c]]
[[castegory:programmering]]
[[category:algoritmer]]

= Bakgrund =

Base24 är inte en standardkodning och den är lite mer komplex än de som baseras på ett jämt antal oktetter som [[base32]] samt [[base64]] men det har en fördel också, vi använder bara stora bokstäver A-X.

= Implementation =
<pre>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

const char ALPHABET[] = "BCDFGHJKMNPQRTVWXY2346789";
#define BASE 24
#define MAX_LINE 70
#define CHARS_PER_BLOCK 6 // 6 tecken för data täcker 24 bitar (24^6 > 2^24)

int get_index(char c) {
for (int i = 0; i < BASE; i++) if (ALPHABET[i] == c) return i;
return -1;
}

void encode_block(const uint8_t *in, int len, char *out_buf) {
uint32_t val = 0;
// Packa indata till en 24-bitars integer
if (len >= 1) val |= ((uint32_t)in[0] << 16);
if (len >= 2) val |= ((uint32_t)in[1] << 8);
if (len >= 3) val |= ((uint32_t)in[2]);

out_buf[0] = ALPHABET[len]; // Header: längd

// Konvertera val till bas 24 över 6 tecken (position 1 till 6)
uint32_t temp = val;
for (int i = CHARS_PER_BLOCK; i >= 1; i--) {
out_buf[i] = ALPHABET[temp % BASE];
temp /= BASE;
}
}

int decode_block(const char *in_buf, uint8_t *out_three) {
int len = get_index(in_buf[0]);
if (len < 0 || len > 3) return -1;

uint32_t val = 0;
for (int i = 1; i <= CHARS_PER_BLOCK; i++) {
int idx = get_index(in_buf[i]);
if (idx == -1) return -1;
// Vi bygger värdet baserat på positionell vikt
val = val * BASE + idx;
}

if (len >= 1) out_three[0] = (uint8_t)((val >> 16) & 0xFF);
if (len >= 2) out_three[1] = (uint8_t)((val >> 8) & 0xFF);
if (len >= 3) out_three[2] = (uint8_t)(val & 0xFF);

return len;
}

void encode_stream() {
printf("--- BEGIN BASE24 ENCODED DATA ---\n");
uint8_t in[3];
char out[CHARS_PER_BLOCK + 1];
int bytes_read, line_pos = 0;
while ((bytes_read = fread(in, 1, 3, stdin)) > 0) {
encode_block(in, bytes_read, out);
for (int i = 0; i < CHARS_PER_BLOCK + 1; i++) {
putchar(out[i]);
if (++line_pos >= MAX_LINE) {
putchar('\n');
line_pos = 0;
}
}
}
if (line_pos > 0) putchar('\n');
printf("--- END BASE24 ENCODED DATA ---\n");
}

void decode_stream() {
int ch, count = 0;
char block[CHARS_PER_BLOCK + 1];
uint8_t out[3];

while ((ch = getchar()) != EOF) {
if (ch == '-' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {
if (ch == '-') while ((ch = getchar()) != '\n' && ch != EOF);
continue;
}
block[count++] = (char)ch;
if (count == CHARS_PER_BLOCK + 1) {
int decoded = decode_block(block, out);
if (decoded > 0) fwrite(out, 1, decoded, stdout);
count = 0;
}
}
}

void run_test_case(const char *name, uint8_t *orig, int len) {
printf("Testar: %s (%d bytes)\n", name, len);

int num_blocks = (len + 2) / 3;
char *encoded = malloc(num_blocks * (CHARS_PER_BLOCK + 1));
for (int i = 0; i < num_blocks; i++) {
int chunk = (len - i * 3 > 3) ? 3 : (len - i * 3);
encode_block(&orig[i * 3], chunk, &encoded[i * (CHARS_PER_BLOCK + 1)]);
}

uint8_t *reconstructed = malloc(num_blocks * 3);
int total_decoded = 0;
for (int i = 0; i < num_blocks; i++) {
int res = decode_block(&encoded[i * (CHARS_PER_BLOCK + 1)], &reconstructed[total_decoded]);
if (res > 0) total_decoded += res;
}

if (total_decoded == len && memcmp(orig, reconstructed, len) == 0) {
printf(" [PASS] Data matchar perfekt.\n");
} else {
printf(" [FAIL] Korruption! Längd: %d/%d\n", total_decoded, len);
}

free(encoded);
free(reconstructed);
}

void run_tests() {
printf("BASE24 SJÄLVTEST - FINAL VERSION\n================================\n");
uint8_t test1[13];
for(int i=0; i<13; i++) test1[i] = (uint8_t)(rand() % 256);
run_test_case("13 bytes slumpdata (inkl. höga bitvärden)", test1, 13);

uint8_t test2[12] = {0};
run_test_case("12 bytes nollor", test2, 12);

uint8_t test3[] = "Klockrent, Täpp-Anders!";
run_test_case("Sträng med UTF-8", test3, strlen((char*)test3));
}

int main(int argc, char *argv[]) {
if (argc < 2) return 1;
if (strcmp(argv[1], "--test") == 0) run_tests();
else if (strcmp(argv[1], "--encode") == 0 || strcmp(argv[1], "-e") == 0) encode_stream();
else if (strcmp(argv[1], "--decode") == 0 || strcmp(argv[1], "-d") == 0) decode_stream();
return 0;
}
</pre>

Base24

2026-04-19T09:53:09Z

Anders: /* Implementation */

= Bakgrund =

Base24 är inte en standardkodning och den är lite mer komplex än de som baseras på ett jämt antal oktetter som [[base32]] samt [[base64]] men det har en fördel också, vi använder bara stora bokstäver A-X.

= Implementation =
<pre>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

const char ALPHABET[] = "BCDFGHJKMNPQRTVWXY2346789";
#define BASE 24
#define MAX_LINE 70
#define CHARS_PER_BLOCK 6 // 6 tecken för data täcker 24 bitar (24^6 > 2^24)

int get_index(char c) {
for (int i = 0; i < BASE; i++) if (ALPHABET[i] == c) return i;
return -1;
}

void encode_block(const uint8_t *in, int len, char *out_buf) {
uint32_t val = 0;
// Packa indata till en 24-bitars integer
if (len >= 1) val |= ((uint32_t)in[0] << 16);
if (len >= 2) val |= ((uint32_t)in[1] << 8);
if (len >= 3) val |= ((uint32_t)in[2]);

out_buf[0] = ALPHABET[len]; // Header: längd

// Konvertera val till bas 24 över 6 tecken (position 1 till 6)
uint32_t temp = val;
for (int i = CHARS_PER_BLOCK; i >= 1; i--) {
out_buf[i] = ALPHABET[temp % BASE];
temp /= BASE;
}
}

int decode_block(const char *in_buf, uint8_t *out_three) {
int len = get_index(in_buf[0]);
if (len < 0 || len > 3) return -1;

uint32_t val = 0;
for (int i = 1; i <= CHARS_PER_BLOCK; i++) {
int idx = get_index(in_buf[i]);
if (idx == -1) return -1;
// Vi bygger värdet baserat på positionell vikt
val = val * BASE + idx;
}

if (len >= 1) out_three[0] = (uint8_t)((val >> 16) & 0xFF);
if (len >= 2) out_three[1] = (uint8_t)((val >> 8) & 0xFF);
if (len >= 3) out_three[2] = (uint8_t)(val & 0xFF);

return len;
}

void encode_stream() {
printf("--- BEGIN BASE24 ENCODED DATA ---\n");
uint8_t in[3];
char out[CHARS_PER_BLOCK + 1];
int bytes_read, line_pos = 0;
while ((bytes_read = fread(in, 1, 3, stdin)) > 0) {
encode_block(in, bytes_read, out);
for (int i = 0; i < CHARS_PER_BLOCK + 1; i++) {
putchar(out[i]);
if (++line_pos >= MAX_LINE) {
putchar('\n');
line_pos = 0;
}
}
}
if (line_pos > 0) putchar('\n');
printf("--- END BASE24 ENCODED DATA ---\n");
}

void decode_stream() {
int ch, count = 0;
char block[CHARS_PER_BLOCK + 1];
uint8_t out[3];

while ((ch = getchar()) != EOF) {
if (ch == '-' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {
if (ch == '-') while ((ch = getchar()) != '\n' && ch != EOF);
continue;
}
block[count++] = (char)ch;
if (count == CHARS_PER_BLOCK + 1) {
int decoded = decode_block(block, out);
if (decoded > 0) fwrite(out, 1, decoded, stdout);
count = 0;
}
}
}

void run_test_case(const char *name, uint8_t *orig, int len) {
printf("Testar: %s (%d bytes)\n", name, len);

int num_blocks = (len + 2) / 3;
char *encoded = malloc(num_blocks * (CHARS_PER_BLOCK + 1));
for (int i = 0; i < num_blocks; i++) {
int chunk = (len - i * 3 > 3) ? 3 : (len - i * 3);
encode_block(&orig[i * 3], chunk, &encoded[i * (CHARS_PER_BLOCK + 1)]);
}

uint8_t *reconstructed = malloc(num_blocks * 3);
int total_decoded = 0;
for (int i = 0; i < num_blocks; i++) {
int res = decode_block(&encoded[i * (CHARS_PER_BLOCK + 1)], &reconstructed[total_decoded]);
if (res > 0) total_decoded += res;
}

if (total_decoded == len && memcmp(orig, reconstructed, len) == 0) {
printf(" [PASS] Data matchar perfekt.\n");
} else {
printf(" [FAIL] Korruption! Längd: %d/%d\n", total_decoded, len);
}

free(encoded);
free(reconstructed);
}

void run_tests() {
printf("BASE24 SJÄLVTEST - FINAL VERSION\n================================\n");
uint8_t test1[13];
for(int i=0; i<13; i++) test1[i] = (uint8_t)(rand() % 256);
run_test_case("13 bytes slumpdata (inkl. höga bitvärden)", test1, 13);

uint8_t test2[12] = {0};
run_test_case("12 bytes nollor", test2, 12);

uint8_t test3[] = "Klockrent, Täpp-Anders!";
run_test_case("Sträng med UTF-8", test3, strlen((char*)test3));
}

int main(int argc, char *argv[]) {
if (argc < 2) return 1;
if (strcmp(argv[1], "--test") == 0) run_tests();
else if (strcmp(argv[1], "--encode") == 0 || strcmp(argv[1], "-e") == 0) encode_stream();
else if (strcmp(argv[1], "--decode") == 0 || strcmp(argv[1], "-d") == 0) decode_stream();
return 0;
}
</pre>

Racket/RLE

2026-04-11T14:45:36Z

Anders:

<pre>

#lang racket

;;;;;
;; RLE – Run Length Encoder
;;
;; I/O via stdio <infil >utfil
;;
;; Kodar data genom att räkna antal förekomster av samma tecken/byte i rad och
;; ersätter den med ett cons-par (antal . tecken) tills nästa förekomst finns.
;; Kan operera binärt men med begränsningen av max 255 bytes konsekutivt sedan
;; startas en ny ram.
;;
;; racket rle.rkt [ --encode | --decode | --help ] [ --binary ] < infil > utfil
;;
;; --encode kodar stdin till stdout lisp style om inte --binary används
;; --decode avkodar stdin till stdout lisp style om inte --binary används
;; --binary skriver kodad data binärt, läser binär data för avkodning
;; --help visar en enkel hjälptext
;; --test kör en enkel sån därn JOONIT TÄST di kallart
;;
;; Saker som kan göras bättre:
;;
;; Det finns ganska lite felkontroll och vad du kastar på dekodern kommer den försöka
;; tills det skiter sig.
;;
;; Man kan också tänka sig att använda mer än en byte för antal i binärt mode
;; men också en grej är ju att man aldrig kommer koda för 0 tecken så man kunde
;; ju lika gärna koda för 1-256 i stället för 0-255. Jag har struntat i det.
;;
;;;;;

;; --- Kärnlogik ---

;; Grupperar element
(define (pack-limited lst)
(cond [(empty? lst) '()]
[else
(let-values ([(prefix suffix) (splitf-at lst (lambda (x) (equal? x (first lst))))])
(if (> (length prefix) 255)
;; Om gruppen är för lång, hugg av vid 255 och fortsätt med resten
(cons (take prefix 255) (pack-limited (append (drop prefix 255) suffix)))
;; Annars, fortsätt som vanligt
(cons prefix (pack-limited suffix))))]))

(define (encode lst)
(map (lambda (group) (list (length group) (first group)))
(pack-limited lst)))

(define (decode lst)
(append-map (lambda (entry) (make-list (first entry) (second entry)))
lst))

;; --- Binär I/O ---

(define (write-binary encoded-data)
(for ([pair encoded-data])
(write-byte (first pair))
(write-byte (second pair))))

(define (read-binary)
(let ([count (read-byte)])
(if (eof-object? count)
'()
(let ([val (read-byte)])
(cons (list count val) (read-binary))))))

;; --- Körlägen ---

(define (run-encode binary?)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))])
(if binary?
(write-binary encoded)
(write encoded)))) ; Använd write för att få korrekt läsbar listformat

(define (run-decode binary?)
(let* ([data (if binary? (read-binary) (read))]
[decoded (decode data)])
(display (list->bytes decoded))))

(define (run-test)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))]
[decoded (list->bytes (decode encoded))])
(if (equal? input decoded)
(printf "Test lyckades! (~a bytes in, ~a noder skapade)\n"
(bytes-length input) (length encoded))
(error "Test misslyckades: Datat korrupt!"))))

;; --- CLI ---

(define (show-help)
(displayln "Användning: racket rle.rkt [FLAGGA] < infil > utfil")
(displayln " -e, --encode Koda (standard: text-listor)")
(displayln " -d, --decode Dekoda (standard: text-listor)")
(displayln " -b, --binary Kör i binärläge (1 byte antal, 1 byte värde)")
(displayln " -t, --test Verifiera att koda+dekoda bevarar data")
(displayln " -h, --help Visa denna hjälp"))

(define (main)
(let ([args (vector->list (current-command-line-arguments))])
(cond
[(member "-t" args) (run-test)]
[(and (member "-e" args) (or (member "-b" args) (member "--binary" args))) (run-encode #t)]
[(member "-e" args) (run-encode #f)]
[(and (member "-d" args) (or (member "-b" args) (member "--binary" args))) (run-decode #t)]
[(member "-d" args) (run-decode #f)]
[else (show-help)])))

(main)

</pre>

Racket/RLE

2026-04-11T14:38:41Z

Anders: Skapade sidan med '<pre> #lang racket ;;;;; ;; RLE – Run Length Encoder ;; ;; I/O via stdio <infil >utfil ;; ;; Kodar data genom att räkna antal förekomster av samma tecken/byte i rad och ;; ersätter den med ett cons-par (antal . tecken) tills nästa förekomst finns. ;; Kan operera binärt men med begränsningen av max 255 bytes konsekutivt sedan ;; startas en ny ram. ;; ;; racket rle.rkt [ --encode | --decode | --help ] [ --binary ] < infil > utfil ;; ;; --encode kodar stdin till...'

<pre>

#lang racket

;;;;;
;; RLE – Run Length Encoder
;;
;; I/O via stdio <infil >utfil
;;
;; Kodar data genom att räkna antal förekomster av samma tecken/byte i rad och
;; ersätter den med ett cons-par (antal . tecken) tills nästa förekomst finns.
;; Kan operera binärt men med begränsningen av max 255 bytes konsekutivt sedan
;; startas en ny ram.
;;
;; racket rle.rkt [ --encode | --decode | --help ] [ --binary ] < infil > utfil
;;
;; --encode kodar stdin till stdout lisp style om inte --binary används
;; --decode avkodar stdin till stdout lisp style om inte --binary används
;; --binary skriver kodad data binärt, läser binär data för avkodning
;; --help visar en enkel hjälptext
;; --test kör en enkel sån därn JOONIT TÄST di kallart
;;;;;

;; --- Kärnlogik ---

;; Grupperar element
(define (pack-limited lst)
(cond [(empty? lst) '()]
[else
(let-values ([(prefix suffix) (splitf-at lst (lambda (x) (equal? x (first lst))))])
(if (> (length prefix) 255)
;; Om gruppen är för lång, hugg av vid 255 och fortsätt med resten
(cons (take prefix 255) (pack-limited (append (drop prefix 255) suffix)))
;; Annars, fortsätt som vanligt
(cons prefix (pack-limited suffix))))]))

(define (encode lst)
(map (lambda (group) (list (length group) (first group)))
(pack-limited lst)))

(define (decode lst)
(append-map (lambda (entry) (make-list (first entry) (second entry)))
lst))

;; --- Binär I/O ---

(define (write-binary encoded-data)
(for ([pair encoded-data])
(write-byte (first pair))
(write-byte (second pair))))

(define (read-binary)
(let ([count (read-byte)])
(if (eof-object? count)
'()
(let ([val (read-byte)])
(cons (list count val) (read-binary))))))

;; --- Körlägen ---

(define (run-encode binary?)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))])
(if binary?
(write-binary encoded)
(write encoded)))) ; Använd write för att få korrekt läsbar listformat

(define (run-decode binary?)
(let* ([data (if binary? (read-binary) (read))]
[decoded (decode data)])
(display (list->bytes decoded))))

(define (run-test)
(let* ([input (port->bytes (current-input-port))]
[encoded (encode (bytes->list input))]
[decoded (list->bytes (decode encoded))])
(if (equal? input decoded)
(printf "Test lyckades! (~a bytes in, ~a noder skapade)\n"
(bytes-length input) (length encoded))
(error "Test misslyckades: Datat korrupt!"))))

;; --- CLI ---

(define (show-help)
(displayln "Användning: racket rle.rkt [FLAGGA] < infil > utfil")
(displayln " -e, --encode Koda (standard: text-listor)")
(displayln " -d, --decode Dekoda (standard: text-listor)")
(displayln " -b, --binary Kör i binärläge (1 byte antal, 1 byte värde)")
(displayln " -t, --test Verifiera att koda+dekoda bevarar data")
(displayln " -h, --help Visa denna hjälp"))

(define (main)
(let ([args (vector->list (current-command-line-arguments))])
(cond
[(member "-t" args) (run-test)]
[(and (member "-e" args) (or (member "-b" args) (member "--binary" args))) (run-encode #t)]
[(member "-e" args) (run-encode #f)]
[(and (member "-d" args) (or (member "-b" args) (member "--binary" args))) (run-decode #t)]
[(member "-d" args) (run-decode #f)]
[else (show-help)])))

(main)

</pre>

Racket

2026-04-11T14:34:37Z

Anders: /* Kodexempel (Sommarhack 2026) */

Emacs

2026-04-10T08:41:25Z

Anders: /* .emacs */

= Configuration =

== .emacs ==

<pre>
;; Custom settings
(custom-set-variables

;; Setting the theme I line
'(custom-enabled-themes '(wheatgrass))

;; Removing splash screen and scratch pad on open
'(inhibit-startup-message t)
'(initial-scratch-message nil)

;; Move all emacs backup files to one and the same directory
;; avoiding file system clutter and problematic behaviour when
;; editing certain folders such as /etc/rc.d/ and similar
'(backup-directory-alist '(("." . "~/.emacs.d/backup-dir"))))

(custom-set-faces) ;; Enable wanted face

;; Allow tex input for Unicode characters
(set-input-method "TeX")

</pre>

[[category:konfigurationsfil]]
[[category:programvara]]
[[category:linux]]

Racket/3D-boll

2026-04-07T18:18:11Z

Anders:

= Version "snurra själv" =

<pre>
#lang racket
(require plot)
(require racket/pretty)
;; En pixelboll iracket
;; Från Buzzern skrivet under påskhelgen

(define π (acos -1))
(define VERTICAL-SPLIT 16)
(define HORIZONTAL-SPLIT 16)
(define PARTICLE-SIZE (* VERTICAL-SPLIT HORIZONTAL-SPLIT))
(define particles (for/vector ([i (in-range PARTICLE-SIZE)])
(make-vector 3)))

;; from scheme.com since normal scheme lacks for/vector
(define make-matrix
(lambda (rows columns)
(do ((m (make-vector rows))
(i 0 (+ i 1)))
((= i rows) m)
(vector-set! m i (make-vector columns)))))

(define (to->deg rad)
(* rad (/ 180 π)))

(define (print-dots amount)
(let myloop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(myloop (+ count 1))))))

(define (generate-xyz radius θ ϕ)
(let* ([x (* radius (sin θ) (cos ϕ))]
[y (* radius (sin θ) (sin ϕ))]
[z (* radius (cos θ))]
)
(vector x y z)))

(define (test-loop amount)
(let loop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(loop (+ count 1))))))

(define (get-angle index split)
(* 2 π index (/ split)))

(define (generate-dots particles)
(let* ([index-y -1])
(for ([row (in-vector particles)]
[index (in-naturals)])
(set! index-y (if (= 0 (modulo index HORIZONTAL-SPLIT))
(+ index-y 1)
index-y))
;(printf " ~a ~a\n" (modulo index HORIZONTAL-SPLIT) index-y)
(define new-θ (get-angle (modulo index HORIZONTAL-SPLIT) HORIZONTAL-SPLIT))
(define new-ϕ (get-angle (modulo index-y VERTICAL-SPLIT) VERTICAL-SPLIT))
(printf " ~a ~a \n" (to->deg new-θ) (to->deg new-ϕ))
;;(vector-set! row 0 )
(vector-set! particles index (generate-xyz 1.0 new-θ new-ϕ)))))

;;(test-loop HORIZONTAL-SPLIT)
;;(generate-xyz 1 π (* 2.0 π))
(generate-dots particles)
(plot3d (points3d particles))

</pre>

= Version "snurrar själv" =

<pre>
#lang racket
(require plot)
(require racket/gui/base)
(require racket/pretty)
;; En pixelboll i racket
;; Från Buzzern skrivet under påskhelgen

(define π (acos -1))
(define HEIGHT 600)
(define WIDTH 800)
(define VERTICAL-SPLIT 16)
(define HORIZONTAL-SPLIT 16)
(define RADIUS 100.0)
(define PARTICLE-SIZE (* VERTICAL-SPLIT HORIZONTAL-SPLIT))
(define particles (for/vector ([i (in-range PARTICLE-SIZE)])
(make-vector 3)))

;; from scheme.com since normal scheme lacks for/vector
(define make-matrix
(lambda (rows columns)
(do ((m (make-vector rows))
(i 0 (+ i 1)))
((= i rows) m)
(vector-set! m i (make-vector columns)))))

(define (to->deg rad)
(* rad (/ 180 π)))

(define (to->rad deg)
(/ (* deg π) 180 ))

(define (print-dots amount)
(let myloop ((count 0))
(if (>= count amount)
'()
(begin
(println count)
(myloop (+ count 1))))))

(define (generate-xyz radius θ ϕ)
(let* ([x (* radius (sin θ) (cos ϕ))]
[y (* radius (sin θ) (sin ϕ))]
[z (* radius (cos θ))]
)
(vector x y z)))

(define (projection x y z width height)
(let* ([camera-distance 300.0] ; Push the object away from the camera
[scale-factor 250.0] ; Keep the object visible after pushing it back
; Translate Z away from the viewer
[z-translated (+ z camera-distance)]
; Prevent divide-by-zero (just in case a point hits exactly 0)
[z-safe (if (= z-translated 0.0) 0.001 z-translated)]

; Perspective projection with scaling
[xp (* x (/ scale-factor z-safe))]
[yp (* y (/ scale-factor z-safe))])
;over to screen coords
(vector (+ xp (/ width 2.0)) (+ (/ height 2.0) yp))
))

(define (get-angle index split)
(* 2 π index (/ split)))

(define (generate-dots particles)
(let* ([index-y -1])
(for ([row (in-vector particles)]
[index (in-naturals)])
(set! index-y (if (= 0 (modulo index HORIZONTAL-SPLIT))
(+ index-y 1)
index-y))
(define new-θ (get-angle (modulo index HORIZONTAL-SPLIT) HORIZONTAL-SPLIT))
(define new-ϕ (get-angle (modulo index-y VERTICAL-SPLIT) VERTICAL-SPLIT))
(vector-set! particles index (generate-xyz RADIUS new-θ new-ϕ)))))

(define (rotateX x y z angle)
(let ([y-new (-(* y (cos angle)) (* z (sin angle)))]
[z-new (+ (* y (sin angle)) (* z (cos angle)))])
(vector x y-new z-new)))

(define (rotateY x y z angle)
(let ([x-new (+(* x (cos angle)) (* z (sin angle)))]
[z-new (+ (* (- x) (sin angle)) (* z (cos angle)))])
(vector x-new y z-new)))

(define angleX 0.1)
(define angleXspeed 0)
(define angleY 0.1)
(define angleYspeed 0)

(define deltaTime (current-milliseconds))
(define my-pen (new pen% [color "blue"] [width 2]))

(define (paint canvas dc)
(send dc clear)
(send dc set-pen
my-pen)
(for ([row (in-vector particles)])
(let* ([rotX (rotateX (vector-ref row 0) (vector-ref row 1) (vector-ref row 2) (to->rad angleXspeed))]
[rotY (rotateY (vector-ref rotX 0) (vector-ref rotX 1) (vector-ref rotX 2) (to->rad angleYspeed))]
[xy (projection (vector-ref rotY 0) (vector-ref rotY 1) (vector-ref rotY 2) WIDTH HEIGHT)])
(send dc draw-point (vector-ref xy 0) (vector-ref xy 1)))))

(define frame (new frame% [label "Animation"] [width WIDTH] [height HEIGHT]))
(define canvas (new canvas% [parent frame] [paint-callback paint]))

(generate-dots particles)

(define timer (new timer% [notify-callback
(lambda ()
;(set! x (add1 x))
(set! deltaTime (- (current-milliseconds) deltaTime))
(set! angleXspeed (* angleX deltaTime))
(set! angleYspeed (* angleY deltaTime))
;(printf "~a\n" (current-milliseconds))
(send canvas refresh)
;(send timer start 16)
)]
[interval #f]
[just-once? #f]
))
(send frame show #t)
(send timer start 16) ; ~60 FPS in best case i guess...

</pre>