Różnica pomiędzy stronami "Liczby losowe – metoda odwracania dystrybuanty" i "Komórki"

Z Henryk Dąbrowski
(Różnica między stronami)
Przejdź do nawigacji Przejdź do wyszukiwania
m (1 wersja)
 
m (1 wersja)
 
Linia 1: Linia 1:
<div style="text-align:right; font-size: 130%; font-style: italic; font-weight: bold;">06.01.2021</div>
+
<div style="text-align:right; font-size: 130%; font-style: italic; font-weight: bold;">03.05.2020</div>
  
__FORCETOC__
 
  
  
  
== Gęstość prawdopodobieństwa i dystrybuanta ==
 
  
Rozważmy funkcję <math>f(x)</math> określoną na <math>\mathbb{R}</math>, nieujemną i całkowalną. Powiemy, że <math>f(x)</math> jest gęstością rozkładu prawdopodobieństwa <math>P</math>, jeżeli dla dowolnego zbioru <math>A \subset \mathbb{R}</math> jest
+
== Uchwyt do komórek przez indeks lub przez nazwę, wpisywanie danych do komórek ==
  
::<math>P(A)=\int\limits_A f(x)dx</math>
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki1()
 +
    <span style='color:#707070;'>'wpisywanie do komórek liczb, tekstu i formuł</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oA1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oB2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oC3 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht = ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'uaktywnienie pierwszego arkusza</span>
 +
    oSht.getColumns().insertByIndex(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>4</span>) <span style='color:#707070;'>'dodajemy cztery kolumny na pozycję pierwszą</span>
 +
   
 +
    <span style='color:#707070;'>'komórki możemy uchwycić przez indeks lub przez nazwę, dla komórek A1, B2 i C3 będziemy mieli:</span>
 +
    oA1 = oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do komórki A1 przez indeks</span>
 +
    oB2 = oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B2&quot;</span>) <span style='color:#707070;'>'uchwyt do komórki B2 przez nazwę</span>
 +
    oC3 = oSht.getCellByPosition(<span style='color:#ff0000;'>2</span>, <span style='color:#ff0000;'>2</span>) <span style='color:#707070;'>'uchwyt do komórki C3 przez indeks</span>
 +
   
 +
    <span style='color:#707070;'>'mając dostęp do komórek możemy wpisywać do nich liczby, tekst i formuły;</span>
 +
    <span style='color:#707070;'>'zauważmy, że nie musimy korzystać ze zdefiniowanych wyżej obiektów oA1, oB2 i oC3</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>).Value = <span style='color:#ff0000;'>3</span>/<span style='color:#ff0000;'>2</span> <span style='color:#707070;'>'wpisujemy liczbę do komórki A1 - nie korzystamy z obiektu oA1</span>
 +
    oB2.<span style='color:#000080;'>String</span> = <span style='color:#ff0000;'>&quot;komórka B2&quot;</span> <span style='color:#707070;'>'wpisujemy tekst do komórki B2</span>
 +
    oC3.Formula = <span style='color:#ff0000;'>&quot;=2*A1&quot;</span> <span style='color:#707070;'>'wpisujemy do komórki C3 formułę, która podwaja wartość komórki A1</span>
 +
   
 +
    MsgBox oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B2&quot;</span>).<span style='color:#000080;'>String</span>
 +
    MsgBox oC3.Value <span style='color:#707070;'>'mamy dostęp do wartości, która wynika z wpisanej do komórki formuły</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
gdzie <math>P(A)</math> jest prawdopodobieństwem przypisanym zbiorowi <math>A</math>.
 
  
Z powyższej definicji wynika natychmiast, że funkcja <math>f(x)</math> musi być unormowana:
+
Uchwyt przez nazwę jest bardzo czytelny, zdefiniowanie obiektu związanego z komórką skraca kod i&nbsp;upraszcza dostęp do komórki, ale uchwyt przez indeks ma ogromną przewagę: umożliwia przetwarzanie komórek za pomocą instrukcji For ... Next i&nbsp;z&nbsp;tego prostego powodu jest najczęściej stosowany.
  
::<math>\int^{+ \infty}_{- \infty} f(x)dx = 1</math>
 
  
  
Dystrybuantą gęstości prawdopodobieństwa <math>f(x)</math> nazywamy funkcję:
 
  
::<math>F(x) = \int^x_{- \infty} f(t)dt</math>
 
  
 +
== Sprawdzanie zawartości komórki i określanie jej typu ==
  
Prawdopodobieństwo, że zmienna losowa przyjmie wartość należącą do przedziału <math>[a, b]</math> wynosi:
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Function </span></b>TypKomorki(oCell <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>) <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span>
 +
    <span style='color:#707070;'>'informuje o rodzaju danych zapisanych w komórce ([http://www.openoffice.org/api/docs/common/ref/com/sun/star/table/CellContentType.html LINK1]), ([https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1table.html LINK2])</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> s <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span>
 +
    <b><span style='color:#1f1c1b;'>Select Case</span></b> oCell.<b><span style='color:#1f1c1b;'>Type </span></b>
 +
    <b><span style='color:#1f1c1b;'>Case</span></b> com.sun.star.table.CellContentType.EMPTY
 +
        s = <span style='color:#ff0000;'>&quot;Pusta&quot;</span>
 +
    <b><span style='color:#1f1c1b;'>Case</span></b> com.sun.star.table.CellContentType.VALUE
 +
        s = <span style='color:#ff0000;'>&quot;Liczba&quot;</span>
 +
    <b><span style='color:#1f1c1b;'>Case</span></b> com.sun.star.table.CellContentType.TEXT
 +
        s = <span style='color:#ff0000;'>&quot;Tekst&quot;</span>
 +
    <b><span style='color:#1f1c1b;'>Case</span></b> com.sun.star.table.CellContentType.FORMULA
 +
        s = <span style='color:#ff0000;'>&quot;Formuła&quot;</span>
 +
    <b><span style='color:#1f1c1b;'>End Select</span></b>
 +
    TypKomorki = s
 +
<b><span style='color:#1f1c1b;'>End Function</span></b></span>
  
::<math>P(a \leqslant x \leqslant b) = \int^b_a f(t)dt = F (b) - F (a)</math>
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki2()
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    MsgBox <span style='color:#0095ff;'>TypKomorki</span>( oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>0</span>) ) <span style='color:#707070;'>'A1</span>
 +
    MsgBox <span style='color:#0095ff;'>TypKomorki</span>( oSht.getCellByPosition(<span style='color:#ff0000;'>1</span>,<span style='color:#ff0000;'>1</span>) ) <span style='color:#707070;'>'B2</span>
 +
    MsgBox <span style='color:#0095ff;'>TypKomorki</span>( oSht.getCellByPosition(<span style='color:#ff0000;'>2</span>,<span style='color:#ff0000;'>2</span>) ) <span style='color:#707070;'>'C3</span>
 +
    MsgBox <span style='color:#0095ff;'>TypKomorki</span>( oSht.getCellByPosition(<span style='color:#ff0000;'>3</span>,<span style='color:#ff0000;'>3</span>) ) <span style='color:#707070;'>'D4</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
Linia 31: Linia 69:
  
  
== Rozkład równomierny <math>U(a, b)</math> ==
+
== Wpisywanie daty do komórki ==
  
Rozkładem równomiernym (prostokątnym) nazywamy rozkład prawdopodobieństwa, dla którego gęstość prawdopodobieństwa <math>f(x)</math> jest równa:
+
Datę możemy wpisać do komórki używając dwóch funkcji: '''DateSerial()''' i '''DateValue()'''. Parametrami dla funkcji DateSerial() są liczby całkowite: rok, miesiąc i dzień danej daty i wywołujemy ją następująco '''DateSerial(YYYY, MM, DD)'''. Parametrem dla funkcji '''DateValue()''' jest tekst zawierający te same dane i wywołujemy tę funkcję następująco '''DateValue("YYYY&#8209;RR&#8209;DD")'''.
  
::<math>f(x) = \left\{ \begin{array}{lll}
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki3()
  0 & \text{dla} & x < a\\
+
    <span style='color:#707070;'>'wpisywanie daty</span>
  \frac{1}{b - a} & \text{dla} & x \in [a, b]\\
+
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA5 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA6 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
  0 & \text{dla} & x > b
+
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
\end{array} \right.</math>
+
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oA5 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>4</span>) <span style='color:#707070;'>'uchwyt do komórki A5</span>
 +
    oA6 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>5</span>) <span style='color:#707070;'>'uchwyt do komórki A6</span>
 +
    oA5.Value <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>DateSerial</span>(<span style='color:#ff0000;'>2000</span>, <span style='color:#ff0000;'>1</span>, <span style='color:#ff0000;'>1</span>) <span style='color:#707070;'>'A5</span>
 +
    oA6.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>DateSerial</span>(<span style='color:#ff0000;'>2000</span>, <span style='color:#ff0000;'>1</span>, <span style='color:#ff0000;'>1</span>) <span style='color:#707070;'>'A6</span>
 +
    MsgBox oA5.Value + <span style='color:#ff0000;'>7</span> <span style='color:#707070;'>'36533 - liczba odpowiadająca dacie 08.01.2000</span>
 +
    MsgBox oA6.<span style='color:#000080;'>String</span> + <span style='color:#ff0000;'>7</span> <span style='color:#707070;'>'ciąg znaków &quot;01.01.20007&quot;</span>
 +
    <span style='color:#707070;'>'formuły wpisane do arkusza, które wykonują takie same obliczenia jak wyżej, nie zwrócą otrzymanych wyżej wartości</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>1</span>,<span style='color:#ff0000;'>4</span>).Formula <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;=A5 + 7&quot;</span> <span style='color:#707070;'>'36533 - wynik w komórce B5</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>1</span>,<span style='color:#ff0000;'>5</span>).Formula <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;=A6 + 7&quot;</span> <span style='color:#707070;'>'36533 - wynik w komórce B6</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
Tak zdefiniowany rozkład równomierny będziemy oznaczali <math>U(a, b)</math>. Dystrybuanta tego rozkładu jest określona wzorem:
+
Datę wpisujemy jako wartość (.Value). W&nbsp;komórce pojawi się liczba całkowita odpowiadająca danej dacie i&nbsp;dopiero zmiana formatu komórki (Formatuj komórki &rarr; Liczby &rarr; Kategoria &rarr; Data) sprawi, że zostanie pokazana data w&nbsp;wybranym formacie.
  
::<math>F(x) = \left\{ \begin{array}{lll}
+
Wpisanie daty jako ciąg znaków (.String) jest możliwe. Data zostanie zapisana w&nbsp;komórce jako tekst (standardowo dosunięty do lewej krawędzi komórki). Oczywiście wszelkie obliczenia na tak zapisanej dacie nie będą już możliwe. Wynika to stąd, że kod makra jest precyzyjny – musimy określić typ wartości zapisanej w&nbsp;komórce (.Value, .String, .Formula), do której się odwołujemy.
  0 & \text{dla} & x < a\\
 
  \frac{x - a}{b - a} & \text{dla} & x \in [a, b]\\
 
  1 & \text{dla} & x > b
 
\end{array} \right.</math>
 
  
 +
W&nbsp;arkuszu wygląda to zupełnie inaczej, bo formuła odwołuje się do komórki, ale w&nbsp;komórce może być wpisana liczba, tekst lub formuła. Problem ten rozwiązano, przyjmując zasadę, że w&nbsp;arkuszu wszystko, co da się zinterpretować jako liczba, należy tak interpretować.
  
Zbiór liczb należących do rozkładu równomiernego <math>U(0, 1)</math> możemy łatwo uzyskać. Przykładowo w arkuszu kalkulacyjnym LibreOffice dostępna jest funkcja <math>\text{LOS}()</math>, która zwraca przypadkową liczbę z przedziału <math>[0, 1)</math>. Pisząc makro mamy dostępną analogiczną funkcję <math>\text{Rnd}()</math>. Liczby losowe generowane przez programy komputerowe nazywamy liczbami pseudolosowymi.
+
Dlatego w&nbsp;arkuszu zostanie wykonane dodawanie: "777" + 1 = 778, jak również dodawanie: "01.01.2000" + 7 = 8.01.2000
  
Dysponując liczbami losowymi <math>u_i</math> należącymi do rozkładu równomiernego <math>U(0, 1)</math> możemy łatwo uzyskać liczby losowe <math>x_i</math> należące do rozkładu równomiernego <math>U(a, b)</math>. Wystarczy skorzystać ze wzoru:
 
  
::<math>x_i = a + (b - a) u_i</math>
 
  
  
Przykład histogramu rozkładu równomiernego <math>U (0, 1)</math> Czytelnik znajdzie w arkuszu kalkulacyjnym: [https://henryk-dabrowski.pl/pliki/rozklady/1_Rownomierny.ods Równomierny]
 
  
 +
== Wpisywanie daty i&nbsp;formatowanie postaci, w&nbsp;jakiej zostanie wyświetlona ==
  
 +
Możemy wpisać do komórki datę i&nbsp;ustawić format, w&nbsp;jakim zostanie wyświetlona. W&nbsp;tym celu należy dla komórki, do której wpisujemy datę, określić jej własność '''NumberFormat'''. Poniżej podaję jakie liczby trzeba wpisać dla najbardziej popularnych formatów daty w&nbsp;przypadku języka polskiego:
  
 +
36 – 31.12.1999<br/>
 +
37 – 31.12.99<br/>
 +
38 – piątek 31 grudnia 1999<br/>
 +
76 – 31 grudnia 1999<br/>
 +
81 – 31 grudnia 1999 r.<br/>
 +
84 – 1999-12-31<br/>
  
  
== Dystrybuanta odwrotna ==
+
Inne wartości łatwo znaleźć rejestrując makro i&nbsp;zmieniając formatowanie komórki. W&nbsp;kodzie zarejestrowanego makra odnajdziemy zawsze tekst '''NumberFormatValue''' i&nbsp;odpowiednią liczbę poniżej. Przykład formatowania:
  
Dystrybuanta odwrotna <math>F^{- 1} (u)</math> przekształca zmienną losową <math>U(0,1)</math> o rozkładzie równomiernym w zmienną losową <math>X</math> o rozkładzie <math>f(x)</math>, któremu odpowiada dystrybuanta <math>F(x)</math>:
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki4()
 +
    <span style='color:#707070;'>'wpisywanie daty i formatowanie postaci w jakiej zostanie wyświetlona</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA7 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oA7 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>6</span>) <span style='color:#707070;'>'uchwyt do komórki A7</span>
 +
    oA7.Value <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>DateValue</span>(<span style='color:#ff0000;'>&quot;1999-12-31&quot;</span>) <span style='color:#707070;'>'36525 - liczba odpowiadająca dacie 31.12.1999</span>
 +
    oA7.NumberFormat <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>36</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
::<math>X = F^{- 1} (U)</math>
 
  
Punktowi <math>u \in [0, 1]</math> zostaje przypisany punkt <math>x = F^{- 1} (u) \in [a, b]</math>. Granice przedziału <math>[a, b]</math> mogą być w ogólności niewłaściwe.
 
  
  
Przykładowo dystrybuanta odwrotna zmiennej losowej o rozkładzie <math>f(x) = e^{- x}</math>, gdzie <math>x \in [0, + \infty)</math> jest równa <math>F^{- 1} (x) = - \log (1 - x)</math>. Zatem wylosowana liczba <math>u_1 = 0.25 \in [0.2, 0.3)</math> z rozkładu <math>U[0, 1]</math> przejdzie w punkt
 
::<math>x_1 = - \log (1 - u_1) = 0.125 \in [0.1, 0.2)</math>
 
  
z rozkładu wykładniczego <math>f(x) = e^{- x}</math>. Podobnie liczba <math>u_2 = 0.95
+
== Wpisywanie wartości logicznej do komórki ==
\in [0.9, 0.1)</math> przejdzie w punkt
 
::<math>x_2 = - \log (1 - u_2) = 1.301 \in [1.3, 1.4)</math>
 
  
Czyli liczby te trafią do innych podprzedziałów, będą zliczane w innych miejscach i utworzą inny histogram. Tak jak to pokazano na rysunku:
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki5()
 +
    <span style='color:#707070;'>'wpisywanie wartości logicznej</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>9</span>).Value <span style='color:#000080;'>=</span> True <span style='color:#707070;'>'A10</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>10</span>).Value <span style='color:#000080;'>=</span> False <span style='color:#707070;'>'A11</span>
 +
    MsgBox <span style='color:#ff0000;'>&quot;W komórkach A10 i A11 widoczne są liczby: -1 i 0&quot;</span>
 +
    <span style='color:#707070;'>'formatujemy komórki, aby zamiast liczb -1 i 0 zostały wyświetlone słowa PRAWDA / TRUE i FAŁSZ / FALSE</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>9</span>).NumberFormat <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>99</span> <span style='color:#707070;'>'A10</span>
 +
    oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>10</span>).NumberFormat <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>99</span> <span style='color:#707070;'>'A11</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
[[File:Dystrybuanta_odwrotna.png|center]]
+
Wartości logiczne wpisujemy tylko jako wartość (.Value). Standardowo wartości logicznej PRAWDA odpowiada liczba -1, a&nbsp;wartości logicznej FAŁSZ odpowiada liczba 0. Należy pamiętać, że każda liczba różna od zera zostanie zinterpretowana jako wartość logiczna PRAWDA, a&nbsp;tylko liczbie zero odpowiada wartość logiczna FAŁSZ.
  
  
  
Przykłady histogramów rozkładu równomiernego <math>U (0, 1)</math> i wykładniczego <math>f(x) = e^{-x}</math> (wygenerowanego z rozkładu równomiernego) Czytelnik znajdzie w arkuszach kalkulacyjnych:
 
  
[https://henryk-dabrowski.pl/pliki/rozklady/1_Rownomierny.ods Równomierny]<br/>
 
[https://henryk-dabrowski.pl/pliki/rozklady/6_Wykladniczy.ods Wykładniczy]
 
  
 +
== Wpisywanie tekstu do komórki i podstawowe formatowanie ==
  
 +
Wpisany do komórki tekst wymaga zazwyczaj ustawienia wielu rożnych opcji formatowania. W tym przykładzie podajemy tylko podstawowe, a w następnym podamy kolejne.
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki6()
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oCll <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oCll <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>).getCellByPosition(<span style='color:#ff0000;'>2</span>, <span style='color:#ff0000;'>2</span>)
 +
    oCll.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;abcd&quot;</span>
 +
    oCll.CellBackColor <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>RGB</span>(<span style='color:#ff0000;'>255</span>, <span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'kolor tła komórki</span>
 +
   
 +
    <span style='color:#707070;'>'ustawienie tekstu w poziomie (STANDARD, LEFT, CENTER, RIGHT, BLOCK, REPEAT) ([https://www.openoffice.org/api/docs/common/ref/com/sun/star/table/CellHoriJustify.html LINK1]), ([https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1table.html LINK2])</span>
 +
    oCll.HoriJustify <span style='color:#000080;'>=</span> com.sun.star.table.CellHoriJustify.RIGHT
 +
   
 +
    <span style='color:#707070;'>'ustawienie tekstu w pionie (STANDARD, TOP, CENTER, BOTTOM) ([https://www.openoffice.org/api/docs/common/ref/com/sun/star/table/CellVertJustify.html LINK1]), ([https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1table.html LINK2])</span>
 +
    oCll.VertJustify <span style='color:#000080;'>=</span> com.sun.star.table.CellVertJustify.BOTTOM
 +
   
 +
    <span style='color:#707070;'>'orientacja tekstu</span>
 +
    oCll.RotateAngle <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>9000</span> <span style='color:#707070;'>'90 stopni obrotu w lewo</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
Przedstawimy teraz kilka przykładów zastosowania tego faktu.
+
Uwaga:
 +
<span style="color: green">oRows.getByIndex(<span style='color:#ff0000;'>0</span>).CellBackColor <span style='color:#000080;'>=</span> -<span style='color:#ff0000;'>1</span> <span style='color:#707070;'>'ustawia brak koloru</span></span>
  
== Rozkład jednomianowy <math>f(x) = (n + 1)x^n</math> ==
 
  
Rozważmy funkcję gęstości prawdopodobieństwa postaci:
 
  
::<math>f(x) = \left\{ \begin{array}{lll}
 
  0 & \text{dla} & x < 0\\
 
  (n + 1) x^n & \text{dla} & x \in [0, 1]\\
 
  0 & \text{dla} & x > 1
 
\end{array} \right.</math>
 
  
  
Łatwo sprawdzamy, że
+
== Wpisywanie tekstu do komórki i dalsze formatowanie ==
::<math>\int^{+ \infty}_{- \infty} f(t)dt = \int^1_0 f (t) dt = (n + 1) \int^1_0 t^n dt = t^{n + 1} \biggr|^1_0 = 1</math>
 
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki7()
 +
    <span style='color:#707070;'>'wpisywanie tekstu do komórki i formatowanie komórki</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oRow <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA15 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oRow <span style='color:#000080;'>=</span> oSht.getRows().getByIndex(<span style='color:#ff0000;'>14</span>) <span style='color:#707070;'>'uchwyt do wiersza o indeksie 14</span>
 +
    oRow.Height <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>1500</span> <span style='color:#707070;'>'ustawia wysokość wiersza równą 15 mm</span>
 +
    oA15 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>,<span style='color:#ff0000;'>14</span>) <span style='color:#707070;'>'uchwyt do komórki A15</span>
 +
    oA15.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;Komórka A15&quot;</span>
 +
    oA15.CellBackColor <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>RGB</span>(<span style='color:#ff0000;'>204</span>, <span style='color:#ff0000;'>153</span>, <span style='color:#ff0000;'>102</span>) <span style='color:#707070;'>'kolor tła komórki</span>
 +
    oA15.CharHeight <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>14</span> <span style='color:#707070;'>'rozmiar czcionki</span>
 +
   
 +
    <span style='color:#707070;'>'grubość czcionki (DONTKNOW, THIN, ULTRALIGHT, LIGHT, SEMILIGHT, NORMAL, SEMIBOLD, BOLD, ULTRABOLD, BLACK) ([http://www.openoffice.org/api/docs/common/ref/com/sun/star/style/CharacterProperties.html LINK1]), ([http://www.openoffice.org/api/docs/common/ref/com/sun/star/awt/FontWeight.html LINK2])</span>
 +
    oA15.CharWeight <span style='color:#000080;'>=</span> com.sun.star.awt.FontWeight.BOLD
 +
   
 +
    oA15.setPropertyValue( <span style='color:#ff0000;'>&quot;IsTextWrapped&quot;</span>, True ) <span style='color:#707070;'>'zawija tekst automatycznie</span>
 +
    oA15.HoriJustify <span style='color:#000080;'>=</span> com.sun.star.table.CellHoriJustify.CENTER <span style='color:#707070;'>'wyśrodkowanie tekstu w poziomie</span>
 +
    oA15.VertJustify <span style='color:#000080;'>=</span> com.sun.star.table.CellVertJustify.CENTER <span style='color:#707070;'>'wyśrodkowanie tekstu w pionie</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
=== Dystrybuanta ===
 
  
::<math>F(x) = \left\{ \begin{array}{lll}
 
  0 & \text{dla} & x < 0\\
 
  x^{n + 1} & \text{dla} & x \in [0, 1]\\
 
  1 & \text{dla} & x > 1
 
\end{array} \right.</math>
 
  
  
=== Dystrybuanta odwrotna ===
 
  
::<math>F^{- 1} (x) = \sqrt[n + 1]{x}</math>
+
== Formatowanie komórki liczbowej ==
  
Jeżeli <math>u_i \in U (0, 1)</math>, to liczby <math>x_i = \sqrt[n + 1]{u_i} \in [0, 1]</math> będą należały do rozkładu <math>f(x) = (n + 1) x^n</math> określonego na odcinku <math>[0, 1]</math>.
+
Funkcja oblicza liczbę całkowitą, która określa, jak zostanie sformatowana komórka liczbowa. Najłatwiej kod formatu (parametr sNumFormat) uzyskać wykorzystując okno "Formatuj komórki". Wybieramy potrzebne ustawienia (liczba miejsc po przecinku, separator tysięcy itd.), kopiujemy otrzymany kod i&nbsp;wykorzystujemy go jako parametr sNumFormat. ([https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide/Formatting_Spreadsheet_Documents LINK])
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Function </span></b>NumberFormatId( sNumFormat <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span>, sLanguage <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span>, sCountry <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span> ) <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>
 +
    <span style='color:#707070;'>'Dla USA: sLanguage=&quot;en&quot;, sCountry=&quot;us&quot;</span>
 +
    <span style='color:#707070;'>'Przykładowo: sNumFormat=&quot;# ###,00&quot;</span>
 +
    <span style='color:#707070;'>'Sposób użycia: Cell.NumberFormat <span style='color:#000080;'>=</span> NumberFormatId(&quot;# ###,00&quot;, &quot;pl&quot;, &quot;pl&quot;)</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> LocalSettings <b><span style='color:#1f1c1b;'>As</span></b> New com.sun.star.lang.Locale
 +
   
 +
    LocalSettings.Language <span style='color:#000080;'>=</span> sLanguage
 +
    LocalSettings.Country <span style='color:#000080;'>=</span> sCountry
 +
    NumberFormatId <span style='color:#000080;'>=</span> ThisComponent.NumberFormats.queryKey(sNumFormat, LocalSettings, True)
 +
    <b><span style='color:#1f1c1b;'>If </span></b>NumberFormatId <span style='color:#000080;'>=</span> -<span style='color:#ff0000;'>1</span> <b><span style='color:#1f1c1b;'>Then</span></b>
 +
        NumberFormatId <span style='color:#000080;'>=</span> ThisComponent.NumberFormats.addNew(sNumFormat, LocalSettings)
 +
    <b><span style='color:#1f1c1b;'>End If</span></b>
 +
<b><span style='color:#1f1c1b;'>End Function</span></b></span>
  
=== Krzywa opisująca histogram ===
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki8()
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oA1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oA1 <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>).getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>) <span style='color:#707070;'>'uchwyt do komórki A1 przez nazwę</span>
 +
    oA1.Value <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>12345.6789</span>
 +
    oA1.NumberFormat <span style='color:#000080;'>=</span> <span style='color:#0095ff;'>NumberFormatId</span>(<span style='color:#ff0000;'>&quot;# ###,00&quot;</span>, <span style='color:#ff0000;'>&quot;pl&quot;</span>, <span style='color:#ff0000;'>&quot;pl&quot;</span>)
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
Załóżmy, że:
 
  
:* wygenerowaliśmy <math>N</math> liczb losowych <math>u_i \in U (0, 1)</math>
 
  
:* obliczyliśmy wartości <math>x_i = \sqrt[n + 1]{u_i}</math>
 
  
:* podzieliliśmy przedział zmienności liczb <math>x_i</math> (w naszym przypadku <math>[0, 1]</math>) na podprzedziały każdy o ustalonej szerokości <math>\Delta</math>
 
  
:* pogrupowaliśmy <math>x_i</math> w poszczególnych podprzedziałach i wyznaczyliśmy ilość <math>g(k)</math> liczb <math>x_i</math> w <math>k</math>-tym podprzedziale
+
== Odczytywanie zawartości komórki i&nbsp;operacje na takich danych ==
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki9()
 +
    <span style='color:#707070;'>'odczytywanie wartości komórki i opercje na tych wartościach</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oA1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA3 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oC1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oC2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> x <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Double</span>, y <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Double</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> s <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>String</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oA1 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyty do komórek</span>
 +
    oA2 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;A2&quot;</span>)
 +
    oA3 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>2</span>)
 +
    oC1 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;C1&quot;</span>)
 +
    oC2 <span style='color:#000080;'>=</span> oSht.getCellByPosition(<span style='color:#ff0000;'>2</span>, <span style='color:#ff0000;'>1</span>)
 +
   
 +
    oA1.Value <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>5</span> <span style='color:#707070;'>'zapisujemy liczbę w komórce A1</span>
 +
    oA2.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;To jest formuła: &quot;</span> <span style='color:#707070;'>'zapisujemy tekst w komórce A2</span>
 +
    oA3.Formula <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;=2*A1&quot;</span> <span style='color:#707070;'>'zapisujemy formułę w komórce A3</span>
 +
   
 +
    x <span style='color:#000080;'>=</span> oA1.Value <span style='color:#707070;'>'odczytujemy liczbę zapisaną w komórce A1</span>
 +
    s <span style='color:#000080;'>=</span> oA2.<span style='color:#000080;'>String</span> <span style='color:#707070;'>'odczytujemy tekst zapisany w komórce A2</span>
 +
    y <span style='color:#000080;'>=</span> oA3.Value <span style='color:#707070;'>'odczytujemy LICZBĘ wyliczoną z formuły zapisanej w komórce A3</span>
 +
   
 +
    oC1.Value <span style='color:#000080;'>=</span> x + y <span style='color:#707070;'>'zapisujemy sumę liczb z komórek A1 i A3</span>
 +
    oC2.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> s &amp; oA3.Formula <span style='color:#707070;'>'zapisujemy połączone teksty: z komórki A2 i odczytaną formułę z komórki A3</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
Jakiej zależności <math>g(k)</math> należy się spodziewać? Prawdopodobieństwo tego, że zmienna losowa przyjmie wartość z <math>k</math>-tego przedziału o szerokości <math>\Delta</math> wyraża się wzorem:
 
  
::<math>P((k - 1) \Delta \leqslant x_i \leqslant k \Delta) = \int^{k \Delta}_{(k - 1) \Delta} f(t)dt \approx f (k \Delta) \cdot \Delta</math>
+
Jeszcze jeden przykład:
  
Przybliżenie jest tym lepsze, im mniejsza jest szerokość przedziałów <math>\Delta</math>. Należy zatem oczekiwać zależności:
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki10()
 +
    <span style='color:#707070;'>'operacje na wartościach odczytanych z komórek</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oA1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA3 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oA4 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oB1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oB2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oB3 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oB4 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    ThisComponent.CurrentController.setActiveSheet(oSht) <span style='color:#707070;'>'aktywacja pierwszego arkusza</span>
 +
    oSht.getColumns().insertByIndex(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>3</span>) <span style='color:#707070;'>'dodajemy trzy kolumny na pozycję pierwszą</span>
 +
    oA1 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;A1&quot;</span>) <span style='color:#707070;'>'uchwyt do komórki A1 przez nazwę</span>
 +
    oA2 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;A2&quot;</span>)
 +
    oA3 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;A3&quot;</span>)
 +
    oA4 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;A4&quot;</span>)
 +
    oB1 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B1&quot;</span>)
 +
    oB2 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B2&quot;</span>)
 +
    oB3 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B3&quot;</span>)
 +
    oB4 <span style='color:#000080;'>=</span> oSht.getCellRangebyName(<span style='color:#ff0000;'>&quot;B4&quot;</span>)
 +
   
 +
    <span style='color:#707070;'>'wpisywanie danych</span>
 +
    oA1.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;abc&quot;</span>
 +
    oA2.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>&quot;123&quot;</span>
 +
    oB1.Value <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>5</span>
 +
    oB2.Value <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>7</span>
 +
   
 +
    <span style='color:#707070;'>'wpisywanie sumy odczytanych wartości do nowej komórki ([https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide/Operators LINK])</span>
 +
    oA3.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> oA1.<span style='color:#000080;'>String</span> &amp; oA2.<span style='color:#000080;'>String</span>
 +
    oB3.Value <span style='color:#000080;'>=</span> oB1.Value + oB2.Value
 +
   
 +
    <span style='color:#707070;'>'operator + można stosować do tekstu, a operator &amp; do liczb - zobacz rezultat ([https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide/Operators LINK])</span>
 +
    oA4.<span style='color:#000080;'>String</span> <span style='color:#000080;'>=</span> oA1.<span style='color:#000080;'>String</span> + oA2.<span style='color:#000080;'>String</span>
 +
    oB4.Value <span style='color:#000080;'>=</span> oB1.Value &amp; oB2.Value
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
::<math>g(k) = N \cdot f (k \Delta) \cdot \Delta = N \Delta \cdot f (k \Delta)</math>
 
  
  
Dla rozkładu jednomianowego na odcinku <math>[0, 1]</math> otrzymamy:
 
  
::<math>g(k) = N \cdot f (k \Delta) \cdot \Delta = N \cdot (n + 1) \cdot (k \Delta)^n \cdot \Delta = (n + 1) N \cdot \Delta^{n + 1} \cdot k^n</math>
 
  
 +
== Ważne własności komórki ==
  
Przykład dla <math>n = 1</math> i <math>n = 2</math>
+
Dysponując uchwytem do komórki, możemy uzyskać uchwyt do arkusza, z&nbsp;którego pochodzi komórka. Poza tym możemy poznać indeks tego arkusza oraz indeks kolumny i&nbsp;wiersza, w&nbsp;których komórka jest położona.
  
Niech <math>N = 10^5</math>, <math>\Delta = 0.01</math>
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki11()
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oCll <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>).getCellByPosition(<span style='color:#ff0000;'>1</span>, <span style='color:#ff0000;'>2</span>)
 +
    oSht <span style='color:#000080;'>=</span> oCll.Spreadsheet <span style='color:#707070;'>'uchwyt do arkusza komórki</span>
 +
    MsgBox oSht.getName()
 +
   
 +
    <span style='color:#707070;'>'indeks arkusza, kolumny i wiersza</span>
 +
    MsgBox oCll.getCellAddress().Sheet
 +
    MsgBox oCll.getCellAddress().Column
 +
    MsgBox oCll.getCellAddress().Row
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
dla <math>n = 1</math>: <math>g(k) = 20 k</math>
 
  
dla <math>n = 2</math>: <math>g(k) = 0.3 k^2</math>
 
  
  
Przykłady histogramów rozkładu jednomianowego <math>f(x) = (n + 1)x^n</math>, dla <math>n = 1, 2</math> Czytelnik znajdzie w arkuszach kalkulacyjnych:
 
  
[https://henryk-dabrowski.pl/pliki/rozklady/2_Jednomianowy_n_1.ods Jednomianowy (n = 1)]<br/>
+
== Obramowanie wokół komórek ==
[https://henryk-dabrowski.pl/pliki/rozklady/3_Jednomianowy_n_2.ods Jednomianowy (n = 2)]
 
  
 +
Procedura pozwala utworzyć obramowanie wokół komórki. Zauważmy od razu, że procedurę można łatwo rozbudować:
 +
::* w przypadku LStyle = 3 (linia podwójna) możemy ustawić szerokość każdej z linii i odległość między nimi – dodając nowe parametry możemy w pełni wykorzystać te możliwości
 +
::* zamiast jednego obiektu oBorder możemy utworzyć cztery różne obiekty: oBorder1, oBorder2, oBorder3, oBorder4 i przypisać je osobno do każdej krawędzi komórki: górnej, prawej, dolnej i lewej
  
  
 +
Przedstawiamy wariant najprostszy, wystarczający w większości przypadków, ale warto pamiętać o możliwości łatwego napisania bardziej skomplikowanych wersji.
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>RangeBorder(oRng <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, LColor <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>, LStyle <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>, LWidth <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>)
 +
    <span style='color:#707070;'>'LStyle: 0-ciągła, 1-kropkowana, 2-przerywana, 3-podwójna, ... ([https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1table_1_1BorderLineStyle.html LINK])</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oBorder <b><span style='color:#1f1c1b;'>as New</span></b> com.sun.star.table.BorderLine2
 +
    oBorder.Color <span style='color:#000080;'>=</span> LColor
 +
    oBorder.LineStyle <span style='color:#000080;'>=</span> LStyle
 +
    <b><span style='color:#1f1c1b;'>If </span></b>LStyle <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>3</span> <b><span style='color:#1f1c1b;'>Then</span></b> <span style='color:#707070;'>'DOUBLE</span>
 +
    <span style='color:#707070;'>'InnerLineWidth - szerokość linii wewnętrznej w 1/100 mm (gdy równa zero, rysowana jest tylko jedna linia)</span>
 +
    <span style='color:#707070;'>'LineDistance - odległość między linią wewnętrzną i linią zewnętrzną w 1/100 mm</span>
 +
    <span style='color:#707070;'>'OuterLineWidth - szerokość pojedynczej linii lub szerokość linii zewnętrznej w 1/100 mm</span>
 +
    <span style='color:#707070;'>'(gdy równa zero, żadna linia nie jest rysowana)</span>
 +
        oBorder.InnerLineWidth <span style='color:#000080;'>=</span> LWidth
 +
        oBorder.LineDistance <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>2</span> * LWidth
 +
        oBorder.OuterLineWidth <span style='color:#000080;'>=</span> LWidth
 +
    <b><span style='color:#1f1c1b;'>Else</span></b>
 +
    <span style='color:#707070;'>'LineWidth - szerokość linii w 1/100 mm (gdy równa zero, żadna linia nie jest rysowana)</span>
 +
    <span style='color:#707070;'>'szerokość linii możemy ustawić dla LStyle <span style='color:#000080;'>=</span>  0, 1, 2, 14, 16, 17</span>
 +
        oBorder.LineWidth <span style='color:#000080;'>=</span> LWidth
 +
    <b><span style='color:#1f1c1b;'>End If</span></b>
 +
    <b><span style='color:#1f1c1b;'>With</span></b> oRng
 +
        .TopBorder <span style='color:#000080;'>=</span> oBorder
 +
        .RightBorder <span style='color:#000080;'>=</span> oBorder
 +
        .BottomBorder <span style='color:#000080;'>=</span> oBorder
 +
        .LeftBorder <span style='color:#000080;'>=</span> oBorder
 +
    <b><span style='color:#1f1c1b;'>End With</span></b>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
== Rozkład postaci <math>f(x) = \tfrac{3}{2} \sqrt{x}</math> ==
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki12()
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> k <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>, n <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Long</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oRng <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getCurrentController().getActiveSheet() <span style='color:#707070;'>'uchwyt do aktywnego arkusza</span>
 +
    oSht.getColumns().insertByIndex(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>20</span>) <span style='color:#707070;'>'dodajemy dwadzieścia kolumn na pozycję pierwszą</span>
 +
    <b><span style='color:#1f1c1b;'>For </span></b>n <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>0</span> <b><span style='color:#1f1c1b;'>To</span></b> <span style='color:#ff0000;'>4</span>
 +
        oSht.getCellByPosition(<span style='color:#ff0000;'>2</span>*n, <span style='color:#ff0000;'>0</span>).Value <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>20</span>*n
 +
        <b><span style='color:#1f1c1b;'>For </span></b>k <span style='color:#000080;'>=</span> <span style='color:#ff0000;'>0</span> <b><span style='color:#1f1c1b;'>To</span></b> <span style='color:#ff0000;'>17</span>
 +
            oSht.getCellByPosition(n, <span style='color:#ff0000;'>2</span>*k+<span style='color:#ff0000;'>2</span>).Value <span style='color:#000080;'>=</span> k
 +
            oRng <span style='color:#000080;'>=</span> oSht.getCellRangeByPosition(<span style='color:#ff0000;'>2</span>*n, <span style='color:#ff0000;'>2</span>*k+<span style='color:#ff0000;'>2</span>, <span style='color:#ff0000;'>2</span>*n, <span style='color:#ff0000;'>2</span>*k+<span style='color:#ff0000;'>2</span>)
 +
            <b><span style='color:#000000;'>Call</span></b> RangeBorder(oRng, <span style='color:#0095ff;'>RGB</span>(<span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>, <span style='color:#ff0000;'>0</span>), k, <span style='color:#ff0000;'>20</span>*n)
 +
        <b><span style='color:#1f1c1b;'>Next </span></b>k
 +
    <b><span style='color:#1f1c1b;'>Next </span></b>n
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
Rozważmy następującą funkcję gęstości prawdopodobieństwa:
 
  
::<math>f(x) = \left\{ \begin{array}{lll}
 
  0 & \text{dla} & x < 0\\
 
  \frac{3}{2} \sqrt{x} & \text{dla} & x \in [0, 1]\\
 
  0 & \text{dla} & x > 1
 
\end{array} \right.</math>
 
  
Czytelnik łatwo sprawdzi, że:
 
  
::<math>\int^{+ \infty}_{- \infty} f(t)dt = 1</math>
 
  
 +
== Kasowanie zawartości komórki ==
  
=== Dystrybuanta ===
+
Nim wykonamy kasowanie zawartości komórki, musimy ustalić co chcemy skasować. Różnym typom zawartości przypisane zostały różne liczby:<br/>
 +
VALUE (1) - liczby niesformatowane jako data i czas<br/>
 +
DATETIME (2) - liczby sformatowane jako data i czas<br/>
 +
STRING (4) - tekst<br/>
 +
ANNOTATION (8) - komentarze<br/>
 +
FORMULA (16) - formuły<br/>
 +
Zobacz więcej: ([http://www.openoffice.org/api/docs/common/ref/com/sun/star/sheet/CellFlags.html LINK])
  
::<math>F(x) = \left\{ \begin{array}{lll}
+
Ustalamy, co chcemy skasować, wybieramy odpowiednie liczby i&nbsp;sumujemy. Znaleziona suma jest parametrem dla metody '''clearContents'''.
  0 & \text{dla} & x < 0\\
 
  x^{3 / 2} & \text{dla} & x \in [0, 1]\\
 
  1 & \text{dla} & x > 1
 
\end{array} \right.</math>
 
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki13()
 +
    <span style='color:#707070;'>'usuwanie zawartości komórki</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    oCll <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>) <span style='color:#707070;'>'tworzymy uchwyt do komórki</span>
 +
    oCll.clearContents(<span style='color:#ff0000;'>7</span>) <span style='color:#707070;'>'usuwa liczby, liczby sformatowane jako data i czas oraz tekst</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
=== Dystrybuanta odwrotna ===
 
  
::<math>F^{- 1} (x) = x^{2 / 3}</math>
 
  
Jeżeli <math>u_i \in U (0, 1)</math>, to liczby <math>x_i = (u_i)^{2 / 3}</math> będą należały do rozkładu <math>f(x) = \tfrac{3}{2} \sqrt{x}</math> określonego na odcinku <math>[0, 1]</math>.
 
  
  
=== Krzywa opisująca histogram ===
+
== Kopiowanie komórek ==
  
::<math>g(k) = N \cdot f (k \Delta) \cdot \Delta = N \cdot \frac{3}{2}
+
Musimy przygotować uchwyty do każdej z&nbsp;komórek (kopiowanej i&nbsp;docelowej), a następnie wywołać metodę arkusza '''copyRange''' z&nbsp;odpowiednimi parametrami ([https://www.openoffice.org/api/docs/common/ref/com/sun/star/sheet/XCellRangeMovement.html#copyRange LINK]).
\cdot \sqrt{k \Delta} \cdot \Delta = \frac{3}{2} \cdot N \Delta^{3 / 2} \cdot \sqrt{k}</math>
 
  
Dla <math>N = 10^5</math>, <math>\Delta = 0.01</math> otrzymujemy: <math>g(k) = 150 \sqrt{k}</math>
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki14()
 +
    <span style='color:#707070;'>'kopiowanie komórki Cll1 do komórki Cll2</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
   
 +
    <span style='color:#707070;'>'tworzymy uchwyty do obydwu komórek:</span>
 +
    oCll1 <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>)
 +
    oCll2 <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;B2&quot;</span>)
 +
   
 +
    <span style='color:#707070;'>'kopiowanie wymaga wywołania metody arkusza '''copyRange''' z następującymi parametrami:</span>
 +
    oSht.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
Przykład histogramu rozkładu postaci <math>f (x) = \tfrac{3}{2} \sqrt{x}</math> Czytelnik znajdzie w arkuszu kalkulacyjnym: [https://henryk-dabrowski.pl/pliki/rozklady/4_Pierwiastek.ods Pierwiastek]
 
  
 +
Gdybyśmy z&nbsp;jakiegoś powodu nie mieli uchwytu do arkusza, z&nbsp;którego wzięliśmy komórki, to możemy zrobić tak:
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki15()
 +
    <span style='color:#707070;'>'kopiowanie komórki Cll1 do komórki Cll2</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oCll1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oCll1 <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>).getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>)
 +
    oCll2 <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>).getCellRangeByName(<span style='color:#ff0000;'>&quot;B2&quot;</span>)
 +
    oCll1.Spreadsheet.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
 +
Jeżeli chcemy komórkę przekopiować do innego arkusza, to postępujemy analogicznie:
  
== Rozkład postaci <math>f(x) = \tfrac{1}{2 \sqrt{ax}}</math> ==
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki16()
 +
    <span style='color:#707070;'>'kopiowanie komórki Cll1 pierwszego arkusza do komórki Cll2 drugiego arkusza</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oSht2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht1 <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    oSht2 <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>1</span>) <span style='color:#707070;'>'uchwyt do drugiego arkusza</span>
 +
   
 +
    <span style='color:#707070;'>'tworzymy uchwyty do obydwu komórek:</span>
 +
    oCll1 <span style='color:#000080;'>=</span> oSht1.getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>)
 +
    oCll2 <span style='color:#000080;'>=</span> oSht2.getCellRangeByName(<span style='color:#ff0000;'>&quot;B2&quot;</span>)
 +
   
 +
    <span style='color:#707070;'>'tak samo, jak to uczyniliśmy wyżej, wywołujemy metodę '''copyRange''' (dowolnego arkusza):</span>
 +
    oSht1.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
Dla <math>a > 0</math> określamy następującą funkcję gęstości prawdopodobieństwa:
 
  
::<math>f(x) = \left\{ \begin{array}{lll}
 
  0 & \text{dla} & x \leqslant 0\\
 
  \frac{1}{2 \sqrt{ax}} & \text{dla} & x \in (0, a]\\
 
  0 & \text{dla} & x > a
 
\end{array} \right.</math>
 
  
Czytelnik łatwo sprawdzi, że:
 
  
::<math>\int^{+ \infty}_{- \infty} f(t)dt = 1</math>
 
  
 +
== Przesuwanie komórek ==
  
=== Dystrybuanta ===
+
Przesuwanie komórek z&nbsp;jednego miejsca arkusza w&nbsp;inne lub z&nbsp;jednego arkusza na drugi wykonujemy dokładnie tak samo, jak kopiowanie. Musimy tym razem użyć metody arkusza '''moveRange''' ([https://www.openoffice.org/api/docs/common/ref/com/sun/star/sheet/XCellRangeMovement.html#moveRange LINK]). Dlatego poprzestaniemy na jednym przykładzie.
  
::<math>F(x) = \left\{ \begin{array}{lll}
+
Musimy przygotować uchwyty do każdej z&nbsp;komórek (kopiowanej i&nbsp;docelowej), a&nbsp;następnie wywołać metodę arkusza '''moveRange''' z&nbsp;odpowiednimi parametrami.
  0 & \text{dla} & x < 0\\
 
  \sqrt{\frac{x}{a}} & \text{dla} & x \in [0, a]\\
 
  1 & \text{dla} & x > a
 
\end{array} \right.</math>
 
  
 +
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki17()
 +
    <span style='color:#707070;'>'przesuwanie komórki Cll1 w miejsce komórki Cll2</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll1 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll2 <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
   
 +
    <span style='color:#707070;'>'tworzymy uchwyty do obydwu komórek:</span>
 +
    oCll1 <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;A1&quot;</span>)
 +
    oCll2 <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;B2&quot;</span>)
 +
   
 +
    <span style='color:#707070;'>'przesuwanie wymaga wywołania metody arkusza '''moveRange''' z następującymi parametrami:</span>
 +
    oSht.moveRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
=== Dystrybuanta odwrotna ===
 
  
::<math>F^{- 1} (x) = ax^2</math>
 
  
Jeżeli <math>u_i \in U (0, 1)</math>, to liczby <math>x_i = au^2_i \in [0, a]</math> będą należały do rozkładu <math>f(x) = \tfrac{1}{2 \sqrt{ax}}</math> określonego na odcinku <math>(0, a]</math>.
 
  
  
=== Krzywa opisująca histogram ===
+
== Usuwanie komórek ==
  
::<math>g(k) = N \cdot f (k \Delta) \cdot \Delta = N \cdot \frac{1}{2\sqrt{ak \Delta}} \cdot \Delta = \frac{N \sqrt{\Delta}}{2 \sqrt{a}} \cdot \frac{1}{\sqrt{k}}</math>
+
Metoda arkusza '''removeRange''' usuwa "fizycznie" wybraną komórkę (jeśli można tak powiedzieć o&nbsp;komórce, która istnieje tylko wirtualnie). Dlatego musimy określić jakie dodatkowe działanie zostanie wykonane, aby w&nbsp;arkuszu nie pozostała "dziura". Mamy do wyboru następujące opcje:
  
 +
::*NONE - '''removeRange''' nie robi nic
 +
::*UP - komórka zostaje usunięta, komórki leżące poniżej zostaną przesunięte w górę
 +
::*LEFT - komórka zostaje usunięta, komórki leżące na prawo zostaną przesunięte w lewo
 +
::*ROWS - komórka zostaje usunięta, wiersze leżące poniżej zostaną przesunięte w górę
 +
::*COLUMNS - komórka zostaje usunięta, kolumny leżące na prawo zostaną przesunięte w lewo
  
Dla <math>a = 25</math>, <math>N = 10^5</math>, <math>\Delta = 0.25</math> otrzymujemy: <math>g(k) = \tfrac{5000}{\sqrt{k}}</math>
 
  
 +
Opcja ROWS odpowiada usunięciu wiersza, w&nbsp;którym położona była komórka. Opcja COLUMNS odpowiada usunięciu kolumny, w&nbsp;której położona była komórka. ([https://www.openoffice.org/api/docs/common/ref/com/sun/star/sheet/XCellRangeMovement.html#removeRange LINK1]), ([https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide/Cells_and_Ranges LINK2])
  
Przykład histogramu rozkładu postaci <math>f (x) = \tfrac{1}{10 \sqrt{x}}</math> określonego na odcinku <math>(0, 25]</math> Czytelnik znajdzie w arkuszu kalkulacyjnym: [https://henryk-dabrowski.pl/pliki/rozklady/5_Odwrotnosc_pierwiastka.ods Odwrotność pierwiastka]
+
<span style="color: green"><b><span style='color:#1f1c1b;'>Sub </span></b>Komorki18()
 +
    <span style='color:#707070;'>'usuwanie komórki B2</span>
 +
    <b><span style='color:#1f1c1b;'>Dim</span></b> oSht <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>, oCll <b><span style='color:#1f1c1b;'>as</span></b> <span style='color:#000080;'>Object</span>
 +
    oSht <span style='color:#000080;'>=</span> ThisComponent.getSheets().getByIndex(<span style='color:#ff0000;'>0</span>) <span style='color:#707070;'>'uchwyt do pierwszego arkusza</span>
 +
    oCll <span style='color:#000080;'>=</span> oSht.getCellRangeByName(<span style='color:#ff0000;'>&quot;B2&quot;</span>) <span style='color:#707070;'>'uchwyt do komórki B2</span>
 +
    oSht.removeRange( oCll.getRangeAddress(), com.sun.star.sheet.CellDeleteMode.UP ) <span style='color:#707070;'>'metoda '''removeRange''' z parametrem UP</span>
 +
<b><span style='color:#1f1c1b;'>End Sub</span></b></span>
  
  
Linia 264: Linia 499:
  
  
== Rozkład wykładniczy <math>f(x) = \lambda e^{- \lambda x}</math> ==
+
== Polecane strony internetowe ==
  
Dla rozkładu wykładniczego funkcja gęstości prawdopodobieństwa jest określona następująco:
+
[https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide/Cells_and_Ranges BASIC Guide – Cells and Ranges]
  
::<math>f(x) = \left\{ \begin{array}{lll}
+
[https://wiki.openoffice.org/wiki/Spreadsheet_common#Working_with_cells Spreadsheet common – Working with cells]
  0 & \text{dla} & x < 0\\
 
  \lambda e^{- \lambda x} & \text{dla} & x \geqslant 0
 
\end{array} \right.</math>
 
  
gdzie <math>\lambda > 0</math>.
+
[http://www.openoffice.org/api/docs/common/ref/com/sun/star/table/CellProperties.html Apache OpenOffice – service CellProperties]
  
  
=== Dystrybuanta ===
 
  
::<math>F(x) = \left\{ \begin{array}{lll}
 
  0 & \text{dla} & x < 0\\
 
  1 - e^{- \lambda x} & \text{dla} & x \geqslant 0
 
\end{array} \right.</math>
 
  
  
=== Dystrybuanta odwrotna ===
 
  
::<math>F^{- 1} (x) = - \frac{1}{\lambda} \cdot \log (1 - x)</math>
 
  
Jeżeli <math>u_i \in U (0, 1)</math>, to liczby <math>x_i = - \frac{1}{\lambda} \cdot \log (1 - u_i)</math> będą należały do rozkładu wykładniczego <math>f(x) = \lambda e^{- \lambda x}</math> określonego na półprostej <math>[0, +\infty)</math>.
 
 
 
=== Krzywa opisująca histogram ===
 
 
::<math>g(k) = N \cdot \lambda e^{- \lambda \cdot k \Delta} \cdot \Delta = N \Delta \cdot \exp (- (\lambda \Delta) \cdot k)</math>
 
 
Dla <math>\lambda = 1</math> oraz <math>N = 10^5</math>, <math>\Delta = 0.1</math> otrzymujemy: <math>g(k) = 10000 \cdot e^{- 0.1 \cdot k}</math>
 
 
 
Przykład histogramu rozkładu wykładniczego <math>f(x) = e^{- x}</math> Czytelnik znajdzie w arkuszu kalkulacyjnym: [https://henryk-dabrowski.pl/pliki/rozklady/6_Wykladniczy.ods Wykładniczy]
 
 
 
 
 
 
== Rozkład normalny <math>N (\mu, \sigma^2)</math> ==
 
 
Rozkładem normalnym nazywamy rozkład, dla którego funkcja gęstości prawdopodobieństwa ma postać:
 
 
::<math>f(x) = \frac{1}{\sigma \sqrt{2 \pi}} \cdot \exp \left( -
 
\frac{(x - \mu)^2}{2 \sigma^2} \right)</math>
 
 
gdzie <math>\mu \in \mathbb{R}</math> i <math>\sigma > 0</math>.
 
 
 
=== Dystrybuanta ===
 
 
::<math>F(x) = \int^x_{- \infty} f (t) dt = \frac{1}{\sqrt{\pi}} \int^{\frac{x - \mu}{\sigma \sqrt{2}}}_{- \infty} e^{-u^2} du = \frac{1}{\sqrt{\pi}} \int^0_{- \infty} e^{- u^2} du + \frac{1}{\sqrt{\pi}} \int^{\frac{x - \mu}{\sigma \sqrt{2}}}_0 e^{- u^2} du</math>
 
 
Ponieważ
 
 
::<math>\frac{1}{\sqrt{\pi}} \int^0_{- \infty} e^{- u^2} du = \frac{1}{2}</math>
 
 
to
 
::<math>F(x) = \frac{1}{2} \left( 1 + \text{erf}\left( \frac{x - \mu}{\sigma \sqrt{2}} \right) \right)</math>
 
 
Funkcję <math>\text{erf}(x)</math> nazywamy funkcją błędu Gaussa i jest to funkcja nieelementarna:
 
 
::<math>\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int^x_0 e^{- t^2} dt</math>
 
 
Łatwo można pokazać, że <math>\text{erf}(x)</math> jest funkcją nieparzystą:
 
 
::<math>\text{erf}(-x) = - \text{erf}(x)</math>
 
 
 
W arkuszu LibreOffice <math>\text{erf}(x)</math> jest dostępna pod nazwą FUNKCJA.BŁ.DOKŁ(). Dostępna jest też komplementarna funkcja błędu <math>\text{erfc}(x) = 1 - \text{erf}(x)</math> pod nazwą KOMP.FUNKCJA.BŁ.DOKŁ(). Funkcja odwrotna funkcji <math>\text{erf}(x)</math> również nie jest elementarna. Dlatego uzyskanie liczb <math>x_i \in N (\mu, \sigma^2)</math> na bazie liczb <math>u_i \in U (0, 1)</math> wymaga nieco innego podejścia.
 
 
 
=== Metoda Boxa - Mullera ===
 
 
Zamiast jednej zmiennej losowej o standardowym rozkładzie normalnym <math>N(0, 1)</math>, rozważmy dwie niezależne zmienne losowe o takim rozkładzie. Funkcja gęstości prawdopodobieństwa dla takiej pary niezależnych zmiennych losowych będzie iloczynem gęstości prawdopodobieństwa tych funkcji:
 
 
::<math>f(x, y) = f (x) f (y) = \frac{1}{\sqrt{2 \pi}} e^{- x^2 / 2} \cdot \frac{1}{\sqrt{2 \pi}} e^{- x^2 / 2} = \frac{1}{2 \pi} e^{- (x^2 + y^2) / 2}</math>
 
 
 
Przechodząc do współrzędnych biegunowych
 
::<math>\left\{ \begin{array}{l}
 
  x = r \cdot \cos (\varphi)\\
 
  y = r \cdot \sin (\varphi)
 
\end{array} \right.</math>
 
 
 
gdzie <math>r \geqslant 0</math> i <math>\varphi \in \left [ 0, 2\pi \right )</math>, otrzymujemy:
 
 
::<math>f (r, \varphi) = \frac{1}{2 \pi} e^{- r^2 / 2}</math>
 
 
 
Funkcję gęstości prawdopodobieństwa <math>f (r, \varphi)</math> możemy zapisać w postaci iloczynu:
 
 
::<math>f (r, \varphi) = g (r) h (\varphi)</math>
 
 
 
Widzimy, że <math>h (\varphi) = \frac{1}{2 \pi} = \text{const}</math> jest unormowaną funkcją gęstości prawdopodobieństwa zmiennej <math>\varphi</math>. Oznacza to, że rozkład <math>\varphi</math> jest rozkładem równomiernym <math>U (0, 2 \pi)</math>, a liczba <math>\varphi</math> może być zapisana w postaci <math>\varphi = 2 \pi \cdot u</math>, gdzie <math>u</math> jest liczbą z równomiernego rozkładu <math>U(0, 1)</math>.
 
 
 
Iloczyn dystrybuant <math>G(r) H (\varphi)</math> jest określony całką we współrzędnych biegunowych:
 
 
::<math>G (\hat{r}) H (\hat{\varphi}) = \int^{\hat{r}}_0 \int^{\hat{\varphi}}_0 g(r) h (\varphi) rdrd \varphi = \int^{\hat{r}}_0 g(r)rdr \int^{\hat{\varphi}}_0 h (\varphi) d \varphi</math>
 
 
 
Zatem dystrybuanta <math>G (\hat{r})</math> jest równa:
 
 
::<math>G (\hat{r}) = \int^{\hat{r}}_0 g(r)rdr = \int^{\hat{r}}_0 e^{- r^2 / 2} rdr = - e^{- r^2 / 2} \biggr|^{\hat{r}}_0 = 1 - e^{- \hat{r}^2 / 2}</math>
 
 
Całkę nieoznaczoną <math>\int e^{- r^2 / 2} rdr = -e^{- r^2 / 2}</math> wyliczamy dokonując podstawienia <math>t = -r^2/2</math>.
 
 
 
Wracając do zmiennej <math>r</math>, mamy:
 
 
::<math>G(r) = 1 - e^{- r^2 / 2}</math>
 
 
 
Łatwo znajdujemy dystrybuantę odwrotną:
 
 
::<math>G^{- 1} (r) = \sqrt{- 2 \log (1 - r)}</math>
 
 
 
Jeżeli <math>v_i \in U (0, 1)</math>, to liczby <math>\sqrt{- 2 \log (1 - v_i)}</math> będą należały do rozkładu prawdopodobieństwa odpowiadającego funkcji <math>g(r)</math>.
 
 
 
Zatem parze liczb <math>u, v \in U (0, 1)</math> odpowiadają liczby <math>\varphi, r</math>
 
 
::<math>\left\{ \begin{array}{l}
 
  \varphi = 2 \pi \cdot u\\
 
  r = \sqrt{- 2 \log (1 - v)}
 
\end{array} \right.</math>
 
 
z rozkładów opisywanych funkcjami gęstości <math>h (\varphi)</math> i <math>g(r)</math>, a tym liczbom odpowiada para liczb <math>x, y</math>
 
 
::<math>\left\{ \begin{array}{l}
 
  x = \sqrt{- 2 \log (1 - v)} \cdot \cos (2 \pi \cdot u)\\
 
  y = \sqrt{- 2 \log (1 - v)} \cdot \sin (2 \pi \cdot u)
 
\end{array} \right.</math>
 
 
które należą do standardowych rozkładów normalnych <math>N(0, 1)</math>.
 
 
 
=== Wnioski ===
 
 
Jeżeli <math>u, v \in U (0, 1)</math>, to liczby
 
::<math>\left\{ \begin{array}{l}
 
  x = \sqrt{- 2 \log (1 - u)} \cdot \cos (2 \pi \cdot v)\\
 
  y = \sqrt{- 2 \log (1 - u)} \cdot \sin (2 \pi \cdot v)
 
\end{array} \right.</math>
 
 
będą należały do standardowego rozkładu normalnego <math>N(0, 1)</math>.
 
 
 
 
Uogólniając postępowanie z poprzedniego punktu, można łatwo pokazać, że jeżeli <math>u, v \in U (0, 1)</math>, to liczby
 
 
::<math>\left\{ \begin{array}{l}
 
  x = \mu + \sigma \sqrt{- 2 \log (1 - u)} \cdot \cos (2 \pi \cdot v)\\
 
  y = \mu + \sigma \sqrt{- 2 \log (1 - u)} \cdot \sin (2 \pi \cdot v)
 
\end{array} \right.</math>
 
 
będą należały do rozkładu normalnego <math>N (\mu, \sigma^2)</math>.
 
 
 
 
Przykład histogramu rozkładu normalnego <math>f (x) = \frac{1}{\sqrt{2 \pi}} e^{- x^2}</math> Czytelnik znajdzie w arkuszu kalkulacyjnym: [https://henryk-dabrowski.pl/pliki/rozklady/7_Normalny.ods Normalny]
 
  
 +
[[LibreOffice Calc – makra | <b>LibreOffice Calc – makra</b>]]&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[[Henryk Dąbrowski | <b>Strona główna</b>]]
  
  

Aktualna wersja na dzień 22:36, 18 wrz 2022

03.05.2020



Uchwyt do komórek przez indeks lub przez nazwę, wpisywanie danych do komórek

Sub Komorki1()
    'wpisywanie do komórek liczb, tekstu i formuł
    Dim oSht as Object
    Dim oA1 as Object, oB2 as Object, oC3 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'uaktywnienie pierwszego arkusza
    oSht.getColumns().insertByIndex(0, 4) 'dodajemy cztery kolumny na pozycję pierwszą
    
    'komórki możemy uchwycić przez indeks lub przez nazwę, dla komórek A1, B2 i C3 będziemy mieli:
    oA1 = oSht.getCellByPosition(0, 0) 'uchwyt do komórki A1 przez indeks
    oB2 = oSht.getCellRangebyName("B2") 'uchwyt do komórki B2 przez nazwę
    oC3 = oSht.getCellByPosition(2, 2) 'uchwyt do komórki C3 przez indeks
    
    'mając dostęp do komórek możemy wpisywać do nich liczby, tekst i formuły;
    'zauważmy, że nie musimy korzystać ze zdefiniowanych wyżej obiektów oA1, oB2 i oC3
    oSht.getCellByPosition(0, 0).Value = 3/2 'wpisujemy liczbę do komórki A1 - nie korzystamy z obiektu oA1
    oB2.String = "komórka B2" 'wpisujemy tekst do komórki B2
    oC3.Formula = "=2*A1" 'wpisujemy do komórki C3 formułę, która podwaja wartość komórki A1
    
    MsgBox oSht.getCellRangebyName("B2").String
    MsgBox oC3.Value 'mamy dostęp do wartości, która wynika z wpisanej do komórki formuły
End Sub


Uchwyt przez nazwę jest bardzo czytelny, zdefiniowanie obiektu związanego z komórką skraca kod i upraszcza dostęp do komórki, ale uchwyt przez indeks ma ogromną przewagę: umożliwia przetwarzanie komórek za pomocą instrukcji For ... Next i z tego prostego powodu jest najczęściej stosowany.



Sprawdzanie zawartości komórki i określanie jej typu

Function TypKomorki(oCell as Object) as String
    'informuje o rodzaju danych zapisanych w komórce (LINK1), (LINK2)
    Dim s as String
    Select Case oCell.Type 
    Case com.sun.star.table.CellContentType.EMPTY
        s = "Pusta"
    Case com.sun.star.table.CellContentType.VALUE
        s = "Liczba"
    Case com.sun.star.table.CellContentType.TEXT
        s = "Tekst"
    Case com.sun.star.table.CellContentType.FORMULA
        s = "Formuła"
    End Select
    TypKomorki = s
End Function
Sub Komorki2()
    Dim oSht as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    MsgBox TypKomorki( oSht.getCellByPosition(0,0) ) 'A1
    MsgBox TypKomorki( oSht.getCellByPosition(1,1) ) 'B2
    MsgBox TypKomorki( oSht.getCellByPosition(2,2) ) 'C3
    MsgBox TypKomorki( oSht.getCellByPosition(3,3) ) 'D4
End Sub



Wpisywanie daty do komórki

Datę możemy wpisać do komórki używając dwóch funkcji: DateSerial() i DateValue(). Parametrami dla funkcji DateSerial() są liczby całkowite: rok, miesiąc i dzień danej daty i wywołujemy ją następująco DateSerial(YYYY, MM, DD). Parametrem dla funkcji DateValue() jest tekst zawierający te same dane i wywołujemy tę funkcję następująco DateValue("YYYY‑RR‑DD").

Sub Komorki3()
    'wpisywanie daty
    Dim oSht as Object, oA5 as Object, oA6 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oA5 = oSht.getCellByPosition(0,4) 'uchwyt do komórki A5
    oA6 = oSht.getCellByPosition(0,5) 'uchwyt do komórki A6
    oA5.Value = DateSerial(2000, 1, 1) 'A5
    oA6.String = DateSerial(2000, 1, 1) 'A6
    MsgBox oA5.Value + 7 '36533 - liczba odpowiadająca dacie 08.01.2000
    MsgBox oA6.String + 7 'ciąg znaków "01.01.20007"
    'formuły wpisane do arkusza, które wykonują takie same obliczenia jak wyżej, nie zwrócą otrzymanych wyżej wartości
    oSht.getCellByPosition(1,4).Formula = "=A5 + 7" '36533 - wynik w komórce B5
    oSht.getCellByPosition(1,5).Formula = "=A6 + 7" '36533 - wynik w komórce B6
End Sub


Datę wpisujemy jako wartość (.Value). W komórce pojawi się liczba całkowita odpowiadająca danej dacie i dopiero zmiana formatu komórki (Formatuj komórki → Liczby → Kategoria → Data) sprawi, że zostanie pokazana data w wybranym formacie.

Wpisanie daty jako ciąg znaków (.String) jest możliwe. Data zostanie zapisana w komórce jako tekst (standardowo dosunięty do lewej krawędzi komórki). Oczywiście wszelkie obliczenia na tak zapisanej dacie nie będą już możliwe. Wynika to stąd, że kod makra jest precyzyjny – musimy określić typ wartości zapisanej w komórce (.Value, .String, .Formula), do której się odwołujemy.

W arkuszu wygląda to zupełnie inaczej, bo formuła odwołuje się do komórki, ale w komórce może być wpisana liczba, tekst lub formuła. Problem ten rozwiązano, przyjmując zasadę, że w arkuszu wszystko, co da się zinterpretować jako liczba, należy tak interpretować.

Dlatego w arkuszu zostanie wykonane dodawanie: "777" + 1 = 778, jak również dodawanie: "01.01.2000" + 7 = 8.01.2000



Wpisywanie daty i formatowanie postaci, w jakiej zostanie wyświetlona

Możemy wpisać do komórki datę i ustawić format, w jakim zostanie wyświetlona. W tym celu należy dla komórki, do której wpisujemy datę, określić jej własność NumberFormat. Poniżej podaję jakie liczby trzeba wpisać dla najbardziej popularnych formatów daty w przypadku języka polskiego:

36 – 31.12.1999
37 – 31.12.99
38 – piątek 31 grudnia 1999
76 – 31 grudnia 1999
81 – 31 grudnia 1999 r.
84 – 1999-12-31


Inne wartości łatwo znaleźć rejestrując makro i zmieniając formatowanie komórki. W kodzie zarejestrowanego makra odnajdziemy zawsze tekst NumberFormatValue i odpowiednią liczbę poniżej. Przykład formatowania:

Sub Komorki4()
    'wpisywanie daty i formatowanie postaci w jakiej zostanie wyświetlona
    Dim oSht as Object, oA7 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oA7 = oSht.getCellByPosition(0,6) 'uchwyt do komórki A7
    oA7.Value = DateValue("1999-12-31") '36525 - liczba odpowiadająca dacie 31.12.1999
    oA7.NumberFormat = 36
End Sub



Wpisywanie wartości logicznej do komórki

Sub Komorki5()
    'wpisywanie wartości logicznej
    Dim oSht as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oSht.getCellByPosition(0,9).Value = True 'A10
    oSht.getCellByPosition(0,10).Value = False 'A11
    MsgBox "W komórkach A10 i A11 widoczne są liczby: -1 i 0"
    'formatujemy komórki, aby zamiast liczb -1 i 0 zostały wyświetlone słowa PRAWDA / TRUE i FAŁSZ / FALSE
    oSht.getCellByPosition(0,9).NumberFormat = 99 'A10
    oSht.getCellByPosition(0,10).NumberFormat = 99 'A11
End Sub


Wartości logiczne wpisujemy tylko jako wartość (.Value). Standardowo wartości logicznej PRAWDA odpowiada liczba -1, a wartości logicznej FAŁSZ odpowiada liczba 0. Należy pamiętać, że każda liczba różna od zera zostanie zinterpretowana jako wartość logiczna PRAWDA, a tylko liczbie zero odpowiada wartość logiczna FAŁSZ.



Wpisywanie tekstu do komórki i podstawowe formatowanie

Wpisany do komórki tekst wymaga zazwyczaj ustawienia wielu rożnych opcji formatowania. W tym przykładzie podajemy tylko podstawowe, a w następnym podamy kolejne.

Sub Komorki6()
    Dim oCll as Object
    oCll = ThisComponent.getSheets().getByIndex(0).getCellByPosition(2, 2)
    oCll.String = "abcd"
    oCll.CellBackColor = RGB(255, 0, 0) 'kolor tła komórki
    
    'ustawienie tekstu w poziomie (STANDARD, LEFT, CENTER, RIGHT, BLOCK, REPEAT) (LINK1), (LINK2)
    oCll.HoriJustify = com.sun.star.table.CellHoriJustify.RIGHT
    
    'ustawienie tekstu w pionie (STANDARD, TOP, CENTER, BOTTOM) (LINK1), (LINK2)
    oCll.VertJustify = com.sun.star.table.CellVertJustify.BOTTOM
    
    'orientacja tekstu
    oCll.RotateAngle = 9000 '90 stopni obrotu w lewo
End Sub


Uwaga:

oRows.getByIndex(0).CellBackColor = -1 'ustawia brak koloru



Wpisywanie tekstu do komórki i dalsze formatowanie

Sub Komorki7()
    'wpisywanie tekstu do komórki i formatowanie komórki
    Dim oSht as Object, oRow as Object, oA15 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oRow = oSht.getRows().getByIndex(14) 'uchwyt do wiersza o indeksie 14
    oRow.Height = 1500 'ustawia wysokość wiersza równą 15 mm
    oA15 = oSht.getCellByPosition(0,14) 'uchwyt do komórki A15
    oA15.String = "Komórka A15"
    oA15.CellBackColor = RGB(204, 153, 102) 'kolor tła komórki
    oA15.CharHeight = 14 'rozmiar czcionki
    
    'grubość czcionki (DONTKNOW, THIN, ULTRALIGHT, LIGHT, SEMILIGHT, NORMAL, SEMIBOLD, BOLD, ULTRABOLD, BLACK) (LINK1), (LINK2)
    oA15.CharWeight = com.sun.star.awt.FontWeight.BOLD
    
    oA15.setPropertyValue( "IsTextWrapped", True ) 'zawija tekst automatycznie
    oA15.HoriJustify = com.sun.star.table.CellHoriJustify.CENTER 'wyśrodkowanie tekstu w poziomie
    oA15.VertJustify = com.sun.star.table.CellVertJustify.CENTER 'wyśrodkowanie tekstu w pionie
End Sub



Formatowanie komórki liczbowej

Funkcja oblicza liczbę całkowitą, która określa, jak zostanie sformatowana komórka liczbowa. Najłatwiej kod formatu (parametr sNumFormat) uzyskać wykorzystując okno "Formatuj komórki". Wybieramy potrzebne ustawienia (liczba miejsc po przecinku, separator tysięcy itd.), kopiujemy otrzymany kod i wykorzystujemy go jako parametr sNumFormat. (LINK)

Function NumberFormatId( sNumFormat as String, sLanguage as String, sCountry as String ) as Long
    'Dla USA: sLanguage="en", sCountry="us"
    'Przykładowo: sNumFormat="# ###,00"
    'Sposób użycia: Cell.NumberFormat = NumberFormatId("# ###,00", "pl", "pl")
    Dim LocalSettings As New com.sun.star.lang.Locale
    
    LocalSettings.Language = sLanguage
    LocalSettings.Country = sCountry
    NumberFormatId = ThisComponent.NumberFormats.queryKey(sNumFormat, LocalSettings, True)
    If NumberFormatId = -1 Then
        NumberFormatId = ThisComponent.NumberFormats.addNew(sNumFormat, LocalSettings)
    End If
End Function
Sub Komorki8()
    Dim oA1 as Object
    oA1 = ThisComponent.getSheets().getByIndex(0).getCellRangeByName("A1") 'uchwyt do komórki A1 przez nazwę
    oA1.Value = 12345.6789
    oA1.NumberFormat = NumberFormatId("# ###,00", "pl", "pl")
End Sub



Odczytywanie zawartości komórki i operacje na takich danych

Sub Komorki9()
    'odczytywanie wartości komórki i opercje na tych wartościach
    Dim oSht as Object
    Dim oA1 as Object, oA2 as Object, oA3 as Object
    Dim oC1 as Object, oC2 as Object
    Dim x as Double, y as Double
    Dim s as String
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oA1 = oSht.getCellByPosition(0, 0) 'uchwyty do komórek
    oA2 = oSht.getCellRangebyName("A2")
    oA3 = oSht.getCellByPosition(0, 2)
    oC1 = oSht.getCellRangebyName("C1")
    oC2 = oSht.getCellByPosition(2, 1)
    
    oA1.Value = 5 'zapisujemy liczbę w komórce A1
    oA2.String = "To jest formuła: " 'zapisujemy tekst w komórce A2
    oA3.Formula = "=2*A1" 'zapisujemy formułę w komórce A3
    
    x = oA1.Value 'odczytujemy liczbę zapisaną w komórce A1
    s = oA2.String 'odczytujemy tekst zapisany w komórce A2
    y = oA3.Value 'odczytujemy LICZBĘ wyliczoną z formuły zapisanej w komórce A3
    
    oC1.Value = x + y 'zapisujemy sumę liczb z komórek A1 i A3
    oC2.String = s & oA3.Formula 'zapisujemy połączone teksty: z komórki A2 i odczytaną formułę z komórki A3
End Sub


Jeszcze jeden przykład:

Sub Komorki10()
    'operacje na wartościach odczytanych z komórek
    Dim oSht as Object
    Dim oA1 as Object, oA2 as Object, oA3 as Object, oA4 as Object
    Dim oB1 as Object, oB2 as Object, oB3 as Object, oB4 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    ThisComponent.CurrentController.setActiveSheet(oSht) 'aktywacja pierwszego arkusza
    oSht.getColumns().insertByIndex(0, 3) 'dodajemy trzy kolumny na pozycję pierwszą
    oA1 = oSht.getCellRangebyName("A1") 'uchwyt do komórki A1 przez nazwę
    oA2 = oSht.getCellRangebyName("A2")
    oA3 = oSht.getCellRangebyName("A3")
    oA4 = oSht.getCellRangebyName("A4")
    oB1 = oSht.getCellRangebyName("B1")
    oB2 = oSht.getCellRangebyName("B2")
    oB3 = oSht.getCellRangebyName("B3")
    oB4 = oSht.getCellRangebyName("B4")
    
    'wpisywanie danych
    oA1.String = "abc"
    oA2.String = "123"
    oB1.Value = 5
    oB2.Value = 7
    
    'wpisywanie sumy odczytanych wartości do nowej komórki (LINK)
    oA3.String = oA1.String & oA2.String
    oB3.Value = oB1.Value + oB2.Value
    
    'operator + można stosować do tekstu, a operator & do liczb - zobacz rezultat (LINK)
    oA4.String = oA1.String + oA2.String
    oB4.Value = oB1.Value & oB2.Value
End Sub



Ważne własności komórki

Dysponując uchwytem do komórki, możemy uzyskać uchwyt do arkusza, z którego pochodzi komórka. Poza tym możemy poznać indeks tego arkusza oraz indeks kolumny i wiersza, w których komórka jest położona.

Sub Komorki11()
    Dim oSht as Object, oCll as Object
    oCll = ThisComponent.getSheets().getByIndex(0).getCellByPosition(1, 2)
    oSht = oCll.Spreadsheet 'uchwyt do arkusza komórki
    MsgBox oSht.getName()
    
    'indeks arkusza, kolumny i wiersza
    MsgBox oCll.getCellAddress().Sheet
    MsgBox oCll.getCellAddress().Column
    MsgBox oCll.getCellAddress().Row
End Sub



Obramowanie wokół komórek

Procedura pozwala utworzyć obramowanie wokół komórki. Zauważmy od razu, że procedurę można łatwo rozbudować:

  • w przypadku LStyle = 3 (linia podwójna) możemy ustawić szerokość każdej z linii i odległość między nimi – dodając nowe parametry możemy w pełni wykorzystać te możliwości
  • zamiast jednego obiektu oBorder możemy utworzyć cztery różne obiekty: oBorder1, oBorder2, oBorder3, oBorder4 i przypisać je osobno do każdej krawędzi komórki: górnej, prawej, dolnej i lewej


Przedstawiamy wariant najprostszy, wystarczający w większości przypadków, ale warto pamiętać o możliwości łatwego napisania bardziej skomplikowanych wersji.

Sub RangeBorder(oRng as Object, LColor as Long, LStyle as Long, LWidth as Long)
    'LStyle: 0-ciągła, 1-kropkowana, 2-przerywana, 3-podwójna, ... (LINK)
    Dim oBorder as New com.sun.star.table.BorderLine2
    oBorder.Color = LColor
    oBorder.LineStyle = LStyle
    If LStyle = 3 Then 'DOUBLE
    'InnerLineWidth - szerokość linii wewnętrznej w 1/100 mm (gdy równa zero, rysowana jest tylko jedna linia)
    'LineDistance - odległość między linią wewnętrzną i linią zewnętrzną w 1/100 mm
    'OuterLineWidth - szerokość pojedynczej linii lub szerokość linii zewnętrznej w 1/100 mm
    '(gdy równa zero, żadna linia nie jest rysowana)
        oBorder.InnerLineWidth = LWidth
        oBorder.LineDistance = 2 * LWidth
        oBorder.OuterLineWidth = LWidth
    Else
    'LineWidth - szerokość linii w 1/100 mm (gdy równa zero, żadna linia nie jest rysowana)
    'szerokość linii możemy ustawić dla LStyle =  0, 1, 2, 14, 16, 17
        oBorder.LineWidth = LWidth
    End If
    With oRng
        .TopBorder = oBorder
        .RightBorder = oBorder
        .BottomBorder = oBorder
        .LeftBorder = oBorder
    End With
End Sub
Sub Komorki12()
    Dim k as Long, n as Long
    Dim oSht as Object, oRng as Object
    oSht = ThisComponent.getCurrentController().getActiveSheet() 'uchwyt do aktywnego arkusza
    oSht.getColumns().insertByIndex(0, 20) 'dodajemy dwadzieścia kolumn na pozycję pierwszą
    For n = 0 To 4
        oSht.getCellByPosition(2*n, 0).Value = 20*n
        For k = 0 To 17
            oSht.getCellByPosition(n, 2*k+2).Value = k
            oRng = oSht.getCellRangeByPosition(2*n, 2*k+2, 2*n, 2*k+2)
            Call RangeBorder(oRng, RGB(0, 0, 0), k, 20*n)
        Next k
    Next n
End Sub



Kasowanie zawartości komórki

Nim wykonamy kasowanie zawartości komórki, musimy ustalić co chcemy skasować. Różnym typom zawartości przypisane zostały różne liczby:
VALUE (1) - liczby niesformatowane jako data i czas
DATETIME (2) - liczby sformatowane jako data i czas
STRING (4) - tekst
ANNOTATION (8) - komentarze
FORMULA (16) - formuły
Zobacz więcej: (LINK)

Ustalamy, co chcemy skasować, wybieramy odpowiednie liczby i sumujemy. Znaleziona suma jest parametrem dla metody clearContents.

Sub Komorki13()
    'usuwanie zawartości komórki
    Dim oSht as Object, oCll as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    oCll = oSht.getCellRangeByName("A1") 'tworzymy uchwyt do komórki
    oCll.clearContents(7) 'usuwa liczby, liczby sformatowane jako data i czas oraz tekst
End Sub



Kopiowanie komórek

Musimy przygotować uchwyty do każdej z komórek (kopiowanej i docelowej), a następnie wywołać metodę arkusza copyRange z odpowiednimi parametrami (LINK).

Sub Komorki14()
    'kopiowanie komórki Cll1 do komórki Cll2
    Dim oSht as Object, oCll1 as Object, oCll2 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    
    'tworzymy uchwyty do obydwu komórek:
    oCll1 = oSht.getCellRangeByName("A1")
    oCll2 = oSht.getCellRangeByName("B2")
    
    'kopiowanie wymaga wywołania metody arkusza copyRange z następującymi parametrami:
    oSht.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
End Sub


Gdybyśmy z jakiegoś powodu nie mieli uchwytu do arkusza, z którego wzięliśmy komórki, to możemy zrobić tak:

Sub Komorki15()
    'kopiowanie komórki Cll1 do komórki Cll2
    Dim oCll1 as Object, oCll2 as Object
    oCll1 = ThisComponent.getSheets().getByIndex(0).getCellRangeByName("A1")
    oCll2 = ThisComponent.getSheets().getByIndex(0).getCellRangeByName("B2")
    oCll1.Spreadsheet.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
End Sub


Jeżeli chcemy komórkę przekopiować do innego arkusza, to postępujemy analogicznie:

Sub Komorki16()
    'kopiowanie komórki Cll1 pierwszego arkusza do komórki Cll2 drugiego arkusza
    Dim oSht1 as Object, oSht2 as Object, oCll1 as Object, oCll2 as Object
    oSht1 = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    oSht2 = ThisComponent.getSheets().getByIndex(1) 'uchwyt do drugiego arkusza
    
    'tworzymy uchwyty do obydwu komórek:
    oCll1 = oSht1.getCellRangeByName("A1")
    oCll2 = oSht2.getCellRangeByName("B2")
    
    'tak samo, jak to uczyniliśmy wyżej, wywołujemy metodę copyRange (dowolnego arkusza):
    oSht1.copyRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
End Sub



Przesuwanie komórek

Przesuwanie komórek z jednego miejsca arkusza w inne lub z jednego arkusza na drugi wykonujemy dokładnie tak samo, jak kopiowanie. Musimy tym razem użyć metody arkusza moveRange (LINK). Dlatego poprzestaniemy na jednym przykładzie.

Musimy przygotować uchwyty do każdej z komórek (kopiowanej i docelowej), a następnie wywołać metodę arkusza moveRange z odpowiednimi parametrami.

Sub Komorki17()
    'przesuwanie komórki Cll1 w miejsce komórki Cll2
    Dim oSht as Object, oCll1 as Object, oCll2 as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    
    'tworzymy uchwyty do obydwu komórek:
    oCll1 = oSht.getCellRangeByName("A1")
    oCll2 = oSht.getCellRangeByName("B2")
    
    'przesuwanie wymaga wywołania metody arkusza moveRange z następującymi parametrami:
    oSht.moveRange( oCll2.getCellAddress(), oCll1.getRangeAddress() )
End Sub



Usuwanie komórek

Metoda arkusza removeRange usuwa "fizycznie" wybraną komórkę (jeśli można tak powiedzieć o komórce, która istnieje tylko wirtualnie). Dlatego musimy określić jakie dodatkowe działanie zostanie wykonane, aby w arkuszu nie pozostała "dziura". Mamy do wyboru następujące opcje:

  • NONE - removeRange nie robi nic
  • UP - komórka zostaje usunięta, komórki leżące poniżej zostaną przesunięte w górę
  • LEFT - komórka zostaje usunięta, komórki leżące na prawo zostaną przesunięte w lewo
  • ROWS - komórka zostaje usunięta, wiersze leżące poniżej zostaną przesunięte w górę
  • COLUMNS - komórka zostaje usunięta, kolumny leżące na prawo zostaną przesunięte w lewo


Opcja ROWS odpowiada usunięciu wiersza, w którym położona była komórka. Opcja COLUMNS odpowiada usunięciu kolumny, w której położona była komórka. (LINK1), (LINK2)

Sub Komorki18()
    'usuwanie komórki B2
    Dim oSht as Object, oCll as Object
    oSht = ThisComponent.getSheets().getByIndex(0) 'uchwyt do pierwszego arkusza
    oCll = oSht.getCellRangeByName("B2") 'uchwyt do komórki B2
    oSht.removeRange( oCll.getRangeAddress(), com.sun.star.sheet.CellDeleteMode.UP ) 'metoda removeRange z parametrem UP
End Sub



Polecane strony internetowe

BASIC Guide – Cells and Ranges

Spreadsheet common – Working with cells

Apache OpenOffice – service CellProperties





LibreOffice Calc – makra                   Strona główna