-mode llama
+```
+The `-mode` argument chooses the prompt format to use. `llama` is for the Llama(2)-chat finetunes, while `codellama`
+probably works better for CodeLlama-instruct. `raw` will produce a simple chatlog-style chat that works with base
+models and various other finetunes. You can also provide a custom system prompt with `-sp`.
-1 re-buy XOR 1 add-on up until break of 5,000
+## Integration and APIs
+- [TabbyAPI](https://github.com/theroyallab/tabbyAPI/) is a FastAPI-based server that provides an OpenAI-style web API
+compatible with [SillyTavern](https://sillytavernai.com/) and other frontends.
-Blind levels will be adjusted for lower chip counts. This is due to a limited number of physical chips that can be put in play
+- [ExUI](https://github.com/turboderp/exui) is a simple, standalone single-user web UI that serves an ExLlamaV2 instance
+directly with chat and notebook modes.
+- [text-generation-webui](https://github.com/oobabooga/text-generation-webui) supports ExLlamaV2 through the **exllamav2**
+and **exllamav2_HF** loaders.
-$10 cash game after tourney (re-buy at will until host calls it for the night)
+## Installation
+### Method 1: Install from source
+To install the current dev version, clone the repo and run the setup script:
-For now, we'll default to Will's place but if the group decides to float, we'll decide that with at least a day's warning.
-Emergency room outreach to chronically addicted individuals. A pilot study.
-There is a dearth of literature describing the treatment needs of substance-abusing or chronically mentally ill homeless individuals who frequently utilize emergency medical services. This homeless subset represents a discrete population in the larger homeless community. We describe a pilot program, supported by local county public funds, and conducted by a local nonprofit social work agency, which was designed to provide intensive case management services to such a population. Outreach and case management activities resulted in linking clients to a broad range of entitlements and community services. Among those receiving outreach and case management services (n = 10), emergency services decreased by 58% in the year following referral compared to the year before (p <.03). Emergency services for the purpose of this study are defined as ambulance response and transport followed by emergency room admission and treatment. Those in a comparable control group (n = 8) showed no decrease in emergency service use. These results suggest that such community-based outreach programs can significantly improve patient outcome and provide substantial cost savings for local governments and hospitals.
-In 2011 Robert attempted to drink 365 beers in 365 days, and he nailed it! What will he do next?
+```
+git clone https://github.com/turboderp/exllamav2
+cd exllamav2
+python setup.py install --user
+```
-Saturday, 29 August 2015
+By default this will also compile and install the Torch C++ extension (`exllamav2_ext`) that the library relies on.
+You can skip this step by setting the `EXLLAMA_NOCOMPILE` environment variable:
-August 22, 2015
+```
+EXLLAMA_NOCOMPILE= python setup.py install --user
+```
-193/1467) Home: All Natural Blonde by Amsterdam Brewery of Ontario: *; 5%, which goes to show how flexible the definition of light is becoming; grainy nose; bland - just a hint of fruit at finish; I imagine it does pay the rent, though;
+This will install the "JIT version" of the package, i.e. it will install the Python components without building the
+C++ extension in the process. Instead, the extension will be built the first time the library is used, then cached in
+`~/.cache/torch_extensions` for subsequent use.
-194/1468) Home: Molotov Lite by Eviltwin Brewing of Connecticut, U.S.A.: **1/2; 8.5% Imperial India Pale Ale; opaque with a fluffy head; off-orange; earthy and resiny with a touch of citrus to the nose; earthy, resiny flavours with a bitter astringent after taste;
-Such valves are used to adjust and modify the volume flow of a fluid through a fluid channel. It is known in this context that the flow of the fluid through the channel is to be controlled by exerting pressure from the outside on a tube in which the fluid channel is formed, such that the pressure is adjusted as a function of a desired volume flow of the fluid through the channel.
-In medical technology, dosing of volume flows takes place, for example, through microvalves or directly through a corresponding pump with which the fluid to be dispensed is acted upon with pressure. Valves are used in medicine and in the cosmetic field, for example, in injection of medically and cosmetically active substances. In addition to the injection of substances for fat reduction or for injection beneath wrinkles, dosed dispensing of a substance is also necessary for application of ink for tattooing or permanent makeup in the cosmetic field. In addition to various vaccinations, medical applications also include, for example, mesotherapy. In these applications, in addition to the simple application of the media, simultaneous administration of multiple media is also provided, so that the media react with one another only after being applied.
-The dosing of the fluid may be performed by means of a contact method or a noncontact method. The fluid-dispensing device thus either does or does not come in contact with the skin. Noncontact devices are also referred to as so-called dispensers. The process of delivering the fluid is itself known as dispensing, jetting or pulsing. This dosing serves to apply substances to the skin or in subsequent substance delivery systems (cf. EP 1 882 491, for example). Contacting may be understood as dosing onto or through a surface.
-All these applications have in common the need for accurate dosing. Problems are often presented by chemical or fluid properties or particles or variable media.
-The document DE 103 37 484 B4 describes a noncontact dosing system, in which a tube is squeezed at a high speed, so that a free-flying droplet of liquid is formed. Dosing frequencies of 50 Hz may be achieved in this way. The design here is an open system without a prepressure. The liquid fills the tube because of the capillary forces, but the maximum dosing quantity and dosing frequency are limited by this design. If there is a backpressure, functioning is very limited or impossible.
-The document DE 693 25 591 T2 describes valve system for switching a flow through flexible tubes. Two positions (bistable open/closed) are selected via a pivotable lever. The liquids should flow through the valve at the coupled flange of this construction, which is manufactured by casting and welding. Possible contamination of the liquid is not prevented, nor can this principle be used as a disposable part or for higher frequencies (>1 Hz).
-The document EP 1 699 560 B1 describes one possibility for pipetting extremely small quantities, but is based essentially on a combination of traditional pipetting systems and the known PipeJet method, i.e., a tube deformation, embodied in this case as a pipette tip. It is thus possible here to dose only extremely small particles which fly through the air to their destination. This method cannot be used for injections because it is impossible to work at a backpressure.
-The document DE 197 06 513 C2 describes a micro-dosing method based on a pressure chamber having a reservoir connection and a fluid outlet. The pressure chamber is reduced in size by a displacement mechanism, so that the fluid is forced to the outlet. A device for detecting the position of the displacement mechanism is essential here.
-The document US 2010/0030152 A1 describes a therapeutic micro-needle system, in which multiple cannulas are used instead of one cannula.
-Q:
+### Method 2: Install from release (with prebuilt extension)
-How to check element visibility independent of parent visibility (jQuery or not)
+Releases are available [here](https://github.com/turboderp/exllamav2/releases), with prebuilt wheels that contain the
+extension binaries. Make sure to grab the right version, matching your platform, Python version (`cp`) and CUDA version.
+Download an appropriate wheel, then run:
-my first Question so please be patient. I have a container that holds a varying number of child elements like this:
-
-
content
-
content
-
content
-
-
content
-
content
-
content
-
<%
+ ' Grab current time from Now() function.
+ ' An '=' sign occurring after a context switch (<%) is shorthand
+ ' for a call to the Write() method of the Response object.
+ Dim timeValue : timeValue = Now %>
+ The time, in 24-hour format, is
+ <%=Hour(timeValue)%>:<%=Minute(timeValue)%>:<%=Second(timeValue)%>.
+
+
+
-This invention relates generally to the reactivation of a catalyst and in particular to the reactivation of a tin oxide-containing catalyst.
-New approaches for extending the life of lasers used in a wide variety of applications are under investigation. One aspect of the rapid progress in this area is that new techniques for long lifetime space applications of high pulse energy, common and rare isotope, closed-cycle CO.sub.2 lasers are being studied. The high-energy, pulsed CO.sub.2 lasers must be operated closed-cycle to conserve gas, especially if rare-isotope gases are used. Rare-isotope gases, such as C.sup.18 O.sub.2 are used for improved transmission of the laser beam in the atmosphere.
-The electrons in electric-discharge CO.sub.2 lasers cause dissociation of some CO.sub.2 into O.sub.2 and CO and attach themselves to electronegative molecules such as O.sub.2, forming negative O.sub.2.sup.- ions, as well as larger negative ion clusters by collisions with CO or other molecules. For closed-cycle, sealed CO.sub.2 laser operation, the concentration of negative ions/clusters may become sufficiently high to form discharge instabilities which may ultimately disrupt the CO.sub.2 laser operation. The decrease in CO.sub.2 concentration due to dissociation into CO and O.sub.2 will reduce the average repetitively pulsed or continuous wave laser power, even if no disruptive negative ion instabilities occur.
-Accordingly, it is the primary object of this invention to extend the lifetime of a catalyst used to combine the CO and O.sub.2 products formed in a laser discharge.
-It is a further object of this invention to accomplish the primary object simply and inexpensively.
-Other objects and advantages will be apparent in the specification which follows.
-Attack on Iran: Hitlerian Act of Aggression
-Essential Reading Regarding Iran by Tony Cartalucci
-November 6, 2011 - As the rhetoric for war with Iran begins to mount, first with the staged DEA-Saudi bomb plot, and now with an upcoming IAEA report supposedly "exposing" Iran's nuclear arms ambitions, it is important to re-read through the signed confessions by the corporate-fascist interests behind this drive for war where it is admitted that:
+using System;
-1. Iran poses no threat to US national security - even if they acquired nuclear arms- rather Iran threatens US interests throughout the Middle East, half-way across the planet.2. Iran desperately wants to avoid armed conflict with both Israel and the West and would use nuclear weapons merely as a defensive deterrence.3. The US and Israel are actively looking to provoke Iran into war with a combination of covert support for destabilization within Iran, supporting listed terrorist organizations, and limited unilateral military first strikes to provoke an Iranian response needed to justify a wider military confrontation.
+namespace interptest
+{
+ class MainClass
+ {
+ static UInt16[] pwmTable =
+{
+ 0,
+ 1,
+ 15,
+ 53,
+ 127,
+ 249,
+ 431,
+ 685,
+ 1023,
+ 1457,
+ 1999,
+ 2661,
+ 3455,
+ 4393,
+ 5487,
+ 6749,
+ 8191,
+ 9825,
+ 11663,
+ 13717,
+ 15999,
+ 18521,
+ 21295,
+ 24333,
+ 27647,
+ 31249,
+ 35151,
+ 39365,
+ 43903,
+ 48777,
+ 53999,
+ 59581,
+ 65535
+};
-All of this is shockingly spelled out in extreme detail within the pages of the corporate-financier funded Brooking Institution report, "Which Path to Perisa?" It is essential that every American, European, and Israeli read just how malicious, callus and eager the globalist elite are to trigger a catastrophic war with the Islamic Republic for the sole purpose of protecting Wall Street and London's hegemony throughout the Middle East.
+ static UInt16 intToPWM(UInt16 intensity)
+ {
+ UInt32 index = ((UInt32)intensity) >> 11;
+ UInt32 low = ((UInt32)pwmTable[index]);
+ UInt32 high = ((UInt32)pwmTable[index + 1]);
+ UInt32 highp = ((UInt32)intensity & 0x7ff) + 1;
+ UInt32 lowp = 0x800 - highp;
+
+ UInt32 mid = (lowp * low + highp * high) >> 11;
+ return (UInt16)mid;
+ }
-Below are links to efforts to cover in detail the key aspects of this increasing war mongering, the key players behind it, including the corporations funding this agenda, as well as irrefutable evidence that illustrates these designs, laid out in 2009 have already begun to unfold.
-Upon reading this information, one will realize with horror how patiently persistent the corporate-financier interests on Wall Street and London have pursued this campaign towards war with Iran, and how absolutely deceitful they are willing to be in order to keep it moving forward. It is absolutely imperative that people understand not only just how contrived the treat of Iran is, but that those peddling the lies of such a threat have, behind closed doors, admitted as much.
+ public static void Main(string[] args)
+ {
+ for (UInt32 i = 0; i < 65536; i++)
+ {
+ UInt16 t = intToPWM((UInt16)i);
+ Console.WriteLine(t);
-Image: Just some of the corporate-sponsors behind the unelected, warmongering "think-tank" Brookings Institution which produced the treasonous "Which Path to Persia?" report.
+ }
+ }
+ }
+}
-....
+ // Suppress all warnings from casts which overflow.
+#![allow(overflowing_literals)]
+
+fn main() {
+ let decimal = 65.4321_f32;
+
+ // Error! No implicit conversion
+ let integer: u8 = decimal;
+ // FIXME ^ Comment out this line
+
+ // Explicit conversion
+ let integer = decimal as u8;
+ let character = integer as char;
+
+ // Error! There are limitations in conversion rules.
+ // A float cannot be directly converted to a char.
+ let character = decimal as char;
+ // FIXME ^ Comment out this line
+
+ println!("Casting: {} -> {} -> {}", decimal, integer, character);
+
+ // when casting any value to an unsigned type, T,
+ // T::MAX + 1 is added or subtracted until the value
+ // fits into the new type
+
+ // 1000 already fits in a u16
+ println!("1000 as a u16 is: {}", 1000 as u16);
+
+ // 1000 - 256 - 256 - 256 = 232
+ // Under the hood, the first 8 least significant bits (LSB) are kept,
+ // while the rest towards the most significant bit (MSB) get truncated.
+ println!("1000 as a u8 is : {}", 1000 as u8);
+ // -1 + 256 = 255
+ println!(" -1 as a u8 is : {}", (-1i8) as u8);
+
+ // For positive numbers, this is the same as the modulus
+ println!("1000 mod 256 is : {}", 1000 % 256);
+
+ // When casting to a signed type, the (bitwise) result is the same as
+ // first casting to the corresponding unsigned type. If the most significant
+ // bit of that value is 1, then the value is negative.
+
+ // Unless it already fits, of course.
+ println!(" 128 as a i16 is: {}", 128 as i16);
+
+ // In boundary case 128 value in 8-bit two's complement representation is -128
+ println!(" 128 as a i8 is : {}", 128 as i8);
+
+ // repeating the example above
+ // 1000 as u8 -> 232
+ println!("1000 as a u8 is : {}", 1000 as u8);
+ // and the value of 232 in 8-bit two's complement representation is -24
+ println!(" 232 as a i8 is : {}", 232 as i8);
+
+ // Since Rust 1.45, the `as` keyword performs a *saturating cast*
+ // when casting from float to int. If the floating point value exceeds
+ // the upper bound or is less than the lower bound, the returned value
+ // will be equal to the bound crossed.
+
+ // 300.0 as u8 is 255
+ println!(" 300.0 as u8 is : {}", 300.0_f32 as u8);
+ // -100.0 as u8 is 0
+ println!("-100.0 as u8 is : {}", -100.0_f32 as u8);
+ // nan as u8 is 0
+ println!(" nan as u8 is : {}", f32::NAN as u8);
+
+ // This behavior incurs a small runtime cost and can be avoided
+ // with unsafe methods, however the results might overflow and
+ // return **unsound values**. Use these methods wisely:
+ unsafe {
+ // 300.0 as u8 is 44
+ println!(" 300.0 as u8 is : {}", 300.0_f32.to_int_unchecked::());
+ // -100.0 as u8 is 156
+ println!("-100.0 as u8 is : {}", (-100.0_f32).to_int_unchecked::());
+ // nan as u8 is 0
+ println!(" nan as u8 is : {}", f32::NAN.to_int_unchecked::());
+ }
+}
-Please also take particular note of the corporations funding this act of Hitlerian aggression against a nation of 70 million at the potential loss of tens of thousands of American and Israeli (and other proxy soldiers') lives, not to mention the incalculable cost of the war to an already crippled American tax payer. Also note that these same corporations will not be losing their sons and daughters nor a single penny in the war effort, in fact, many of them stand to gain untold of fortunes and power - the very reason they are pursuing such a course of action.
+// This function only gets compiled if the target OS is linux
+#[cfg(target_os = "linux")]
+fn are_you_on_linux() {
+ println!("You are running linux!");
+}
-Now would be a good time to contact your representatives, boycott the above mentioned corporations, and begin undermining a system that is parasitically bleeding this planet to death both financially and literally in pursuit of global corporate-fascist hegemony. And remember, it will not end in Iran, the attack and destruction of Iranian sovereignty is just the beginning.
-Q:
+// And this function only gets compiled if the target OS is *not* linux
+#[cfg(not(target_os = "linux"))]
+fn are_you_on_linux() {
+ println!("You are *not* running linux!");
+}
-Volume rendering in WebGL
+fn main() {
+ are_you_on_linux();
-I have:
+ println!("Are you sure?");
+ if cfg!(target_os = "linux") {
+ println!("Yes. It's definitely linux!");
+ } else {
+ println!("Yes. It's definitely *not* linux!");
+ }
+}
-a 3D array containing a 3d dataset to be displayed
-a 4x4 matrix which defines spacing/scaling/orientation of the volume to be displayed
-a opacity transfer function
-a color transfer function
+struct Droppable {
+ name: &'static str,
+}
-I would like to use ThreeJS to do volume rendering (MIP, RayCasting, etc.) of this data. Are there some shaders/demos available?
-Should I work directly at the shader level or in javascript?
-Any hint/code sample would be very much appreciated,
-Best
+// This trivial implementation of `drop` adds a print to console.
+impl Drop for Droppable {
+ fn drop(&mut self) {
+ println!("> Dropping {}", self.name);
+ }
+}
-A:
+fn main() {
+ let _a = Droppable { name: "a" };
-Medical imaging (DICOM, Nifti, NRRD support for now) raycasting volume rendering in webGL with AMI/THREEJS
-http://fnndsc.github.io/ami/#vr_singlepass_raycasting
+ // block A
+ {
+ let _b = Droppable { name: "b" };
+ // block B
+ {
+ let _c = Droppable { name: "c" };
+ let _d = Droppable { name: "d" };
-2 Answers
-2
+ println!("Exiting block B");
+ }
+ println!("Just exited block B");
-The first two. Christopher Lloyd's character, Judge Doom, is the big conspirator organising the whole situation, but it's the head of Roger's studio, R. K. Maroon, who does the actual setup.
+ println!("Exiting block A");
+ }
+ println!("Just exited block A");
+
+ // Variable can be manually dropped using the `drop` function
+ drop(_a);
+ // TODO ^ Try commenting this line
+
+ println!("end of the main function");
+
+ // `_a` *won't* be `drop`ed again here, because it already has been
+ // (manually) `drop`ed
+}
+
+
+#include "Comms.h"
-He was the one to setup the situation between Acme and Jessica (the patty-cake), and he was also the one to hire Eddie Valiant to take pictures of the meeting. Then later when Valiant meets with Maroon to show him the results, they show Roger the pictures and he runs off to write his love poem, causing him to not have an alibi for the murder.
+Subdevice::Subdevice(const uint8_t _address, Device& _device) :
+ address(_address),
+ next(NULL),
+ device(_device)
+{
+ device.AddSubdevice(this);
+}
-Judge Doom convinces Maroon to do all of this by agreeing to buy his company, but only if he can also buy Acme at the same time. However it was never Maroon's intention for there to be a murder, he was just hoping to blackmail Acme into selling.
+MainSubdevice::MainSubdevice(const uint8_t _address, Device& _device) :
+ Subdevice(_address, _device)
+{}
-No, you gotta understand, Valiant, I had nothin' to do with Acme gettin' killed. I just wanted to sell my studio. But they wouldn't buy my property unless Acme would sell his. And he wouldn't. So I was gonna blackmail Acme with pictures of him and the rabbit's wife.
+void MainSubdevice::command(const uint32_t cmd)
+{
+ switch (cmd)
+ {
+ case MAINSUBDEVICE_CMD_PING: cmd_ping(); break;
+ case MAINSUBDEVICE_CMD_LIST_SUBDEVICES: cmd_list_subdevices(); break;
+
+ default:
+ device.send32(ERROR_BAD_COMMAND);
+ break;
+ }
+}
-Judge Doom wanted to buy ToonTown but Marvin Acme wouldn't sell. Accordingly, Doom asked R.K. Maroon to blackmail Acme. As a result, Doom knew Maroon had shown Roger evidence that Jessica Rabbit was having an affair with Acme. So Doom used the opportunity to kill Acme, hoping everyone would think Roger did it.
+void MainSubdevice::cmd_ping()
+{
+ device.send32(ACK);
+}
-Though Acme's murder is not shown in the movie, what happened is confirmed by Jessica Rabbit's dialogue: Judge Doom killed Marvin Acme and framed Roger Rabbit.
-Para que llegue un jugador a Newell's como refuerzo, antes la directiva rojinegra debe cumplir un paso previo: vender. Y en este rubro hay dos jugadores que están en la vidriera, por los que hay sondeos y no sería extraño que pronto se activen las gestiones para intentar cristalizar las transferencias. Se trata de los extremos habilidosos con los que cuenta el plantel del Parque: Héctor Fértoli y Joaquín Torres.
+void MainSubdevice::cmd_list_subdevices()
+{
+ int size = 9;
+ uint32_t* p = (uint32_t*) (device.txBuffer + 4);
+ *p++ = id();
+
+ Subdevice* subdevice = this;
+ while (subdevice = subdevice->next)
+ {
+ *p++ = subdevice->id();
+ size += 4;
+ }
+ device.finishPacket(size);
+}
-Uno de los jugadores leprosos de mejor torneo fue justamente Fértoli, por el que hay varios clubes interesados en sumarlo. Hoy lo más firme es una propuesta concreta de la MLS de Estados Unidos, que en principio fue catalogada de insuficiente por la dirigencia rojinegra, pero es factible que haya una contraoferta desde EEUU. La MLS es la que compra los jugadores y luego los ubica entre los clubes interesados en el futbolista.
+Device::Device(const uint8_t _address) :
+ address(_address),
+ subdevices(NULL),
+ mainSubdevice(MainSubdevice(0, *this))
+{
+ Serial.begin(115200);
+ rxHead = 0;
+ rxTail = 0;
+ lastRX = millis();
+}
-Por el lado de Joaquín Torres hay un interés del club Sporting de Portugal, que en breve elevará la oferta formal. Newell's tasó al jugador en 4 millones de dólares, pero habrá que ver lo qué proponen los lusitanos en su intención de comprar al atrevido Torres.
-Q:
+void Device::pump()
+{
+ readSerial();
+
+ int rec = rxTail - rxHead;
+ if (rec < 0) rec += RX_BUFFER_SIZE;
+
+ if (rec >= 2)
+ {
+ uint8_t a = rxBuffer[rxHead];
+ uint8_t b = rxBuffer[(rxHead + 1) & RX_BUFFER_MASK];
+ int exp = (b << 8) | a;
+
+ if (exp == rec)
+ {
+ if (exp < 9)
+ {
+ // malformed packet
+ Serial.println("malform"); // TODO
+ rxHead = (rxHead + exp) & RX_BUFFER_MASK;
+ }
+ else if (!checkChecksum())
+ {
+ // failed checksum
+ Serial.println("badchecsum"); // TODO
+ rxHead = (rxHead + exp) & RX_BUFFER_MASK;
+ }
+ else
+ {
+ uint16_t size = consume16();
+ uint8_t deviceAddress = consume8();
+ if (deviceAddress != address)
+ {
+ rxHead = (rxHead + size - 3) & RX_BUFFER_MASK;
+ }
+ else
+ {
+ uint8_t subdeviceAddress = consume8();
+ uint32_t command = consume32();
+ int endOfPacket = (rxHead + size - 8) & RX_BUFFER_MASK;
+ dispatch(subdeviceAddress, command);
+ rxHead = endOfPacket;
+ }
+ }
+ }
+ }
+}
-How to call a MainWindow method from another window?
+void Device::readSerial()
+{
+ if (Serial.available())
+ {
+ uint8_t input = Serial.read();
+ rxBuffer[rxTail++] = input;
+ rxTail &= RX_BUFFER_MASK;
+
+ if (rxTail == rxHead)
+ {
+ // overflow
+ }
+
+ Serial.write(input);// TODO
+ lastRX = millis();
+ }
+ else if (rxTail != rxHead)
+ {
+ uint32_t timeSinceReceive = millis() - lastRX;
+ if (timeSinceReceive >= RX_TIMEOUT)
+ {
+ Serial.println("tieout"); // TODO
+ rxHead = rxTail;
+ }
+ }
+}
-I need to call a method from the MainWindow in another window.
-Problem is i don't know why i got an error and i would like to fix it.
-I tried to call the fonction using various ways, none of them worked.
-Here is my last try :
-What i want to call :
-namespace Class1
+void Device::dispatch(const uint8_t subdeviceAddress, const uint32_t cmd)
{
- public partial class MainWindow : Window
- {
- ...
- public void SkipVideo()
- {
- ...
- }
- }
+ Subdevice* subdevice = subdevices;
+
+ while (subdevice != NULL)
+ {
+ if (subdevice->address == subdeviceAddress)
+ {
+ subdevice->command(cmd);
+ return;
+ }
+ subdevice = subdevice->next;
+ }
+ send32(ERROR_SUBDEVICE_NOT_FOUND);
}
-Here is how i tried to call :
-namespace Class1
+uint8_t Device::consume8()
{
- public partial class TimeWindow : Window
- {
- ...
- private void DemoVideo_MediaEnded(object sender, RoutedEventArgs e)
- {
- ((MainWindow)Application.Current.MainWindow).SkipVideo();
- }
- }
+ uint8_t a = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ return a;
}
-There is no build error, but when i run the program, it does this :
-System.InvalidCastException: 'Unable to cast object of type 'Class1.TimeWindow' to type 'Class1.MainWindow'.'
+uint16_t Device::consume16()
+{
+ uint8_t a = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ uint8_t b = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ return (((uint16_t)b) << 8) | ((uint16_t) a);
+}
-A:
+uint32_t Device::consume32()
+{
+ uint8_t a = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ uint8_t b = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ uint8_t c = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ uint8_t d = rxBuffer[rxHead++];
+ rxHead &= RX_BUFFER_MASK;
+ return (((uint32_t)d) << 24) | (((uint32_t)c) << 16) | (((uint32_t)b) << 8) | ((uint32_t)a);
+}
-The InvalidCastException means that your application's mainwindow is a TimeWindow.
-Provided that there actually is a MainWindow open, you can get a reference to it like this:
-private void DemoVideo_MediaEnded(object sender, RoutedEventArgs e)
+void Device::send32(const uint32_t msg)
{
- MainWindow mainWindow = Application.Current.Windows.OfType().FirstOrDefault();
- if (mainWindow != null)
- mainWindow.SkipVideo();
+ uint32_t* p = (uint32_t*) (txBuffer + 4);
+ *p = msg;
+ finishPacket(9);
}
-There are better ways to handle this, for example using the MVVM design pattern as suggested by @Christopher, but this is probably the easiest one given your current setup.
+static const uint8_t crc_table[] =
+{
+ 0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31,
+ 0x24, 0x23, 0x2a, 0x2d, 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
+ 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 0xe0, 0xe7, 0xee, 0xe9,
+ 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
+ 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1,
+ 0xb4, 0xb3, 0xba, 0xbd, 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
+ 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 0xb7, 0xb0, 0xb9, 0xbe,
+ 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
+ 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16,
+ 0x03, 0x04, 0x0d, 0x0a, 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
+ 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 0x89, 0x8e, 0x87, 0x80,
+ 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
+ 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8,
+ 0xdd, 0xda, 0xd3, 0xd4, 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
+ 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 0x19, 0x1e, 0x17, 0x10,
+ 0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
+ 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f,
+ 0x6a, 0x6d, 0x64, 0x63, 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
+ 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 0xae, 0xa9, 0xa0, 0xa7,
+ 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
+ 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef,
+ 0xfa, 0xfd, 0xf4, 0xf3
+};
+bool Device::checkChecksum()
+{
+ uint8_t crc = 0;
-## About this example
-This example is a [quickstart](https://eggjs.org/zh-cn/intro/quickstart.html) of Egg, it includes the basic and comprehensive usages of Egg such as Controller, Service and some
-simple configurations, moreover, it has the corresponding unit tests. you can follow this simple example and build your Egg application step by step.
+ int c = rxHead;
+ int ce = rxTail - 1;
-## How to run it locally
+ while (c != ce)
+ {
+ crc = crc_table[crc ^ rxBuffer[c++]];
+ c &= RX_BUFFER_MASK;
+ }
-### Development
-```shell
-$ npm install
-$ npm run dev
-$ open http://localhost:7001/
-```
+ return crc == rxBuffer[c];
+}
-### Deploy
+void Device::finishPacket(const int len)
+{
+ txBuffer[0] = len & 0xff;
+ txBuffer[1] = len >> 8;
+ txBuffer[2] = 0;
+ txBuffer[3] = 0;
-Use `EGG_SERVER_ENV=prod` to enable prod mode
+ uint8_t crc = 0;
-```shell
-$ EGG_SERVER_ENV=prod npm start
-```
+ uint8_t* p = txBuffer;
+ uint8_t* pe = txBuffer + len - 1;
-### Npm Scripts
+ while(p < pe)
+ {
+ crc = crc_table[crc ^ *p++];
+ }
-- Use `npm run autod` to auto detect dependencies upgrade
-- Use `npm run lint` to check code style
-- Use `npm test` to run unit test
+ *p = crc;
+ Serial.write(txBuffer, len);
+}
-### Requirement
+void Device::AddSubdevice(Subdevice* subdevice)
+{
+ if (subdevices == NULL)
+ {
+ subdevices = subdevice;
+ }
+ else
+ {
+ Subdevice* dev = subdevices;
+ while (dev->next) dev = dev->next;
+ dev->next = subdevice;
+ }
+}
-Please ensure your node version is `>=8.0` for Egg2.x.
-## some problems you might encounter
-- lack of MVC model development experience, click [here](https://www.zhihu.com/question/27897315) to learn more
-- some concepts such as middleware, extend, helper are difficult to understand, see related [docs](https://eggjs.org/) to know more
-- encounter some errors during development, find [issues](https://github.com/eggjs/egg/issues) to check if some solutions have been provided
-Joseph Amoah (sprinter)
+# ExLlama
-Joseph Paul Amoah (born 12 January 1997) is a Ghanaian sprinter specializing in the 100 metres and the 200 metres. He competed at the 2019 World Athletics Championships in the 100 metres and 4 × 100 metres relay, and at the 2019 African Games he won a gold medal in the 4 × 100 metres relay. He was also a 100 metres finalist at the 2019 African Games, finishing fourth.
+A standalone Python/C++/CUDA implementation of Llama for use with 4-bit GPTQ weights, designed to be fast and
+memory-efficient on modern GPUs.
-Amoah has personal best times of 10.01 seconds and 20.08 seconds in the 100 metres and 200 metres respectively, both set at the 2019 NCAA Division I Championships. His personal best performance in the 200 metres broke the Ghanaian record previously held by three-time Olympian Emmanuel Tuffour by 0.07 seconds.
+Disclaimer: The project is coming along, but it's still a work in progress!
-Early life
-Amoah was born on 12 January 1997 to Thomas and Alberta Amoah in Greater Accra, Ghana, and was raised by his uncle Dr. Victor Antwi from middle school onwards. His preferred sport growing up was football, but transitioned to athletics while attending Prempeh College in Kumasi where his running talent was discovered. As a 19-year old he emerged as an Olympic hopeful for Ghana in the sprints after running 100 metres in 10.08 seconds at the 2016 Ghana's Fastest Human competition.
+## Hardware requirements
-University
-After his prep career at Prempeh College, he decided to quit athletics when enrolling into Kwame Nkrumah University of Science and Technology (KNUST). However the head coach of athletics at KNUST had heard of Amoah's talent while at Prempeh college and convinced Amoah to join the team with the help of his uncle. In 2017 he transferred to Coppin State University in Baltimore, which competes in Division I of the National Collegiate Athletic Association (NCAA), the highest level of intercollegiate athletics in the United States.
+I am developing on an RTX 4090 and an RTX 3090-Ti. 30-series and later NVIDIA GPUs should be well supported, but
+anything Pascal or older with poor FP16 support isn't going to perform well.
+[AutoGPTQ](https://github.com/PanQiWei/AutoGPTQ) or [GPTQ-for-LLaMa](https://github.com/qwopqwop200/GPTQ-for-LLaMa)
+are better options at the moment for older GPUs. ROCm is also theoretically supported (via HIP) though I currently
+have no AMD devices to test or optimize on.
-At the 2019 Mid-Eastern Athletic Conference Championships in May, Amoah became the first Ghanaian in any sport to qualify for the 2020 Summer Olympics by running 200 metres in a personal best time in 20.20 seconds. It was the fastest performance from a Ghanaian since 1995 and also qualified him for the 2019 World Athletics Championships. Later in June of that season at the NCAA Division I Championships, he improved his personal best times in the 100 metres and 200 metres to 10.01 seconds and 20.08 seconds respectively. He broke three-time Olympian Emmanuel Tuffour's 24-year old Ghanaian record in the 200 metres (20.15 seconds, set at altitude), and qualified for the 2020 Summer Olympics in the 100 metres.
+## Dependencies
-Achievements
+* Python 3.9 or newer
+* `torch` tested on 2.0.1 and 2.1.0 (nightly) with cu118
+* `safetensors` 0.3.2
+* `sentencepiece`
+* `ninja`
-International championships
+Additionally, only for the web UI:
-National championships
+* `flask`
+* `waitress`
-References
+## Linux/WSL prerequisites
-External links
+ pip install --pre torch --index-url https://download.pytorch.org/whl/nightly/cu118
-Category:Ghanaian male sprinters
-Category:1997 births
-Category:Living people
-Category:People from Greater Accra Region
-Category:World Athletics Championships athletes for Ghana
-Category:Athletes (track and field) at the 2019 African Games
-Category:African Games medalists in athletics (track and field)
-Category:Coppin State University alumni
-Category:Prempeh College alumni
-Consanguineous unions and endogamy in families of beta-thalassaemia patients from two Mediterranean populations: Tunisia and Italy.
-Background: Consanguinity increases the incidence of recessive diseases such as beta-thalassaemia major (βTM), one of the most prevalent lethal inherited diseases in the world.Aim: This study aims to identify the frequency of endogamy and consanguinity in two Mediterranean βTM populations and to study the implication of socio-economic factors.Subjects and methods: A trans-sectional study was conducted in 203 Tunisian families and 75 Italian families. Data were collected using a questionnaire completed by patients and parents.Results: Complete endogamy and consanguinity were observed in 82.75% and 62.56% of Tunisian families, respectively. Complete endogamy was found in 90.67% of Italian families, no consanguinity was noted. The low occupation status of Tunisian mothers was associated with an increasing frequency of consanguinity (p = .01) and endogamy (p = .0003). Consanguinity was associated with low education level (p = .012) and low occupation status (p=.047) of fathers. No significant association was found between endogamy and socio-economic factors in the Italian sample.Conclusions: High consanguinity and endogamy rates in Tunisian families may explain the frequency of βTM in Tunisia. The high endogamy rate in Italian families could also increase the frequency of βTM. Identification of geographical distribution and socio-economic factors leading to endogamy and consanguinity in these populations might help to improve βTM prevention.
-Purchasing
+## Windows prerequisites
-Violation/Penalties
+To run on Windows (without WSL):
-Purchasing Violations:
+1. Install [MSVC 2022](https://visualstudio.microsoft.com/downloads/). You can choose to install the whole `Visual
+Studio 2022` IDE, or alternatively just the `Build Tools for Visual Studio 2022` package (make sure `Desktop
+development with C++` is ticked in the installer), it doesn't really matter which.
+2. Install the appropriate version of [PyTorch](https://pytorch.org/get-started/locally/), choosing one of the CUDA
+versions. I am developing on the nightly build, but the stable version (2.0.1) should also work.
+3. Install CUDA Toolkit, ([11.7](https://developer.nvidia.com/cuda-11-7-0-download-archive) and
+[11.8](https://developer.nvidia.com/cuda-11-8-0-download-archive) both seem to work, just make sure to match PyTorch's
+Compute Platform version).
+4. For best performance, enable Hardware Accelerated GPU Scheduling.
-What is a purchasing violation?
-Section 31-7-57 of the MS Code states that when an employee receives goods or services without a purchase order, the agency has no liability for the bill. The employee is held personally liable.
+## How to
-A purchasing violation is committed when an employee receives goods or services without a purchase order
+Clone repo, install dependencies, and run benchmark:
-A purchasing violation is when an office prepares intentionally two or more office requisitions to the same vendor when one order combined is greater than $1,500. This is done to avoid getting written quotes/sealed bids. This is called splitting a purchase order.
+ git clone https://github.com/turboderp/exllama
+ cd exllama
-A violation is when an employee personally utilizes a rebate, gift or prize given to the agency by a vendor.
+ pip install -r requirements.txt
-PLEASE NOTE: When any employee orders or receives goods/services in the name of the Department of Education before requesting a purchase order, the employee will be held personally liable for the bill. Do not send the requisition and invoice to Accounting.
+ python test_benchmark_inference.py -d -p -ppl
-UNALLOWABLE AGENCY PURCHASES
+The CUDA extension is loaded at runtime so there's no need to install it separately. It will be compiled on the first
+run and cached to `~/.cache/torch_extensions/` which could take a little while. If nothing happens at first, give it
+a minute to compile.
-Individual membership to professional organizations
+Chatbot example:
-Individual Chamber of Commerce membership
+ python example_chatbot.py -d -un "Jeff" -p prompt_chatbort.txt
-Individual personalization of planners, portfolios or briefcases
+## Python module
-Certificates to state employees, public officials or board members
+jllllll currently maintains an installable Python module [here](https://github.com/jllllll/exllama) which may be more
+suitable for integrating ExLlama with other projects
-Plaques to state employees, public officials or board members
+## Web UI
-Awards to state employees, public officials or board members
+I also made a simple web UI for it. Don't look at the JavaScript, it was mostly written by ChatGPT and it will haunt
+your dreams. But it sort of works, and it's kinda fun, especially multibot mode:
-PENALTIES FOR PURCHASING VIOLATIONS
+
-Reprimands
+To run it:
-Loss of Job
+ pip install -r requirements-web.txt
-Fines
+ python webui/app.py -d
-Imprisonment
+Note that sessions are stored in `~/exllama_sessions/` by default. You can change that location with `-sd` if you want.
-Repayment of misspent funds
+## Docker
-Vendor will re-bill order to the individual
+For security benefits and easier deployment, it is also possible to run the web UI in an isolated docker container. Note: the docker image currently only supports NVIDIA GPUs.
-Sole Source Justification:
-The sole source justification letter should include the following information:
+### Requirements
-What will the product be used for?
+- [Docker](https://docs.docker.com/engine/install/)
+- [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
-Is it compatible with existing equipment?
+It is recommended to run docker in [rootless mode](https://docs.docker.com/engine/security/rootless/).
-Will the product be used for testing or trial use only?
+### Build
-Do other companies make similiar products that are acceptable?
+The easiest way to build the docker image is using docker compose. First, set the `MODEL_PATH` and `SESSIONS_PATH` variables in the `.env` file to the actual directories on the host. Then run:
-How is the product special or unique?
+```
+docker compose build
+```
-What can this product do that other products cannot do?
+It is also possible to manually build the image:
-Is there a copyright or patent on this product?
+```
+docker build -t exllama-web .
+```
-Is the manufacturer the only distributor?
+NOTE: by default, the service inside the docker container is run by a non-root user. Hence, the ownership of bind-mounted directories (`/data/model` and `/data/exllama_sessions` in the default `docker-compose.yml` file) is changed to this non-root user in the container entrypoint (`entrypoint.sh`). To disable this, set `RUN_UID=0` in the `.env` file if using `docker compose`, or the following command if you manually build the image:
-Does the manufacturer only sell to specific distributors instead of direct sales?
-Introduction {#s1}
-============
+```
+docker build -t exllama-web --build-arg RUN_UID=0 .
+```
-In recent years there has been a substantial increase in the use of mass drug administration (MDA) to reduce the morbidity associated with helminth infections of humans [@pntd.0000211-Lammie1], increasing the probability that anthelmintic resistance may become a public health concern in the future. One such annual MDA programme is the Global Programme to Eliminate Lymphatic Filariasis (GPELF) which, in 2005, treated over 145 million people with albendazole (a broad spectrum benzimidazole anthelmintic) in combination with either ivermectin or diethylcarbamazine [@pntd.0000211-WHO1]. GPELF targets mainly *Wuchereria bancrofti*, the most widely distributed of the filarial parasites of humans.
+### Run
-Sensitive molecular assays are required to detect the presence of anthelmintic resistance before widespread treatment failure is apparent, drug resistance becomes disseminated and disease control is jeopardised [@pntd.0000211-Roos1]. Surveys of helminth parasites of humans are being conducted to establish whether genetic changes at certain polymorphic loci (associated with resistance to the same or related drugs used against veterinary helminths), are present in these populations and subject to detectable selection under chemotherapeutic pressure [@pntd.0000211-Albonico1]--[@pntd.0000211-Schwab1]. A phenylalanine to tyrosine substitution at position 200 on the β-tubulin isotype 1 molecule has been identified in a number of helminth parasites of farmed ruminants including *Haemonchus contortus* [@pntd.0000211-Kwa1],[@pntd.0000211-Kwa2], *Cooperia oncophora* [@pntd.0000211-Njue1], and *Teladorsagia circumcincta* [@pntd.0000211-Elard1] and is associated with benzimidazole (BZ) resistance in these species. Worryingly, this genetic change has also been identified in *W. bancrofti* [@pntd.0000211-Schwab1], though the phenotypic studies relating the substitution to a decreased albendazole efficacy have not been undertaken in this species. To aid clarity the two alleles at position 200 on the β-tubulin isotype 1 molecule shall be referred to as allele *F* (phenylalanine) for susceptibility and allele *Y* (tyrosine) for putative resistance.
+Using docker compose:
-Inbreeding, the mating of related individuals, influences parasite genotype distribution and can affect the selection of adaptive traits. Facets of a species\' biology may cause parasite inbreeding, such as population structure or assortative mating (when mate choice is determined by phenotype). Parasite allele frequency can differ between infrapopulations (the populations of parasites within individual hosts) due to the ecology of the infection or through the random nature of infection events (all groups may have an equal probability of having a rare allele, but actual numbers may vary between groups by chance). Helminth parasites have a particularly subdivided population structure as adult worms are confined within their definitive host, and only able to mate with other worms that belong to the same infrapopulation. The population genetic structure of most helminth species remains unknown. The few studies that have been undertaken indicate that whilst some species appear to have no apparent genetic structure others exhibit a high degree of parasite genetic differentiation between hosts [@pntd.0000211-Criscione1]. The degree of genetic differentiation in the parasite infrapopulation can shed insight into the microepidemiology of parasite transmission [@pntd.0000211-Anderson1]--[@pntd.0000211-Thron1]. Infrapopulation genetic differentiation will also influence helminth population genetics as it causes a reduction in the frequency of heterozygote offspring, a phenomenon known as the Wahlund effect [@pntd.0000211-Hartl1].
+```
+docker compose up
+```
-Studies investigating the inheritance of benzimidazole resistance are lacking, though evidence indicates that thiabendazole resistance in *H. contortus* may be a semi-dominant trait [@pntd.0000211-LeJambre1]. Other authors have postulated that alleles conferring anthelmintic resistance, including allele *Y*, are likely to be recessive [@pntd.0000211-Elard1],[@pntd.0000211-Prichard1], which would make heterozygote worms susceptible to treatment. If an allele conferring drug resistance is recessive, excess parasite homozygosity will increase the probability that a resistance allele will survive treatment. This has been shown using genetic metapopulation models investigating nematodes of grazing animals; these models indicate that the spread of rare recessive genes is promoted by hosts accumulating multiple related infections simultaneously [@pntd.0000211-Cornell1],[@pntd.0000211-Smith1]. The degree of parasite genetic differentiation among hosts can be quantified using *F~ST~* (or related analogues; see [@pntd.0000211-Criscione1] and references therein).
+The web UI can now be accessed on the host at http://localhost:5000.
-The adult stages of the majority of parasitic helminths of humans cannot be obtained routinely for direct investigation, so genetic surveys (including those investigating drug resistance) resort to sampling transmission stages, i.e. those (immature) life-stages that gain access to the environment to be transmitted to and from hosts or through vectors [@pntd.0000211-Schwab1], [@pntd.0000211-Curtis1]--[@pntd.0000211-Shrivastava1]. However, the results of these surveys should be interpreted with caution, as the underlying allele frequency of the adult worm population may differ from the allele frequency of the sampled transmission stages. Variations in transmission stage allele frequency and genotype distribution could be generated randomly or be a product of the parasite\'s spatial structure and life-history traits. For example, population subdivision will cause random variation in adult worm allele frequencies between hosts at low parasite densities. Filarial parasites have separate sexes and are thought to be polygamous [@pntd.0000211-SchulzKey1], which may accentuate the variability in microfilarial allele frequency, e.g. a rare allele may be highly over-represented in the subsequent generation if, by chance, a male worm with this allele inhabits a host harbouring females but no other males. In addition, the inherent random sampling of gametes during sexual reproduction [@pntd.0000211-Weir1], and the overdispersed distribution of parasite numbers among hosts [@pntd.0000211-Anderson2] may cause the allele frequency and genotype distribution to vary by chance from generation to generation.
+The configuration can be viewed in `docker-compose.yml` and changed by creating a `docker-compose.override.yml` file.
-This paper analyses population genetic data collected for a study by Schwab *et al.* [@pntd.0000211-Schwab1] who identified the presence of the β-tubulin allele *Y* in populations of *W. bancrofti*. Firstly, the extent of parasite inbreeding is estimated from *W. bancrofti* microfilarial samples taken from patients in Burkina Faso, West Africa. Samples were obtained from different villages, some of which had received a single round of MDA with ivermectin and albendazole, under the auspices of the GPELF. Secondly, an individual-based stochastic model is presented which simulates microfilarial genetic diversity from adult worm allele frequencies. The model generates sample allele and genotype frequencies using the same number of hosts, and the same number of microfilariae per host as in Schwab *et al.* [@pntd.0000211-Schwab1]. This model is then used to assess whether the observed level of parasite inbreeding is the result of a sampling artefact or a true biological phenomenon. Finally, the model is used to assess the likely range of adult worm allele frequencies which could have given rise to the observed microfilarial data, providing some insight into how genetic surveys which sample transmission stages should be interpreted. We discuss the implications of our results in terms of the development and detection of anthelmintic resistance.
+Run manually:
-Materials and Methods {#s2}
-=====================
+```
+docker run --gpus all -p 5000:5000 -v :/data/model/ -v :/data/exllama_sessions --rm -it exllama-web --host 0.0.0.0:5000
+```
-Sampled data {#s2a}
-------------
-[Table 1](#pntd-0000211-t001){ref-type="table"} summarises the data collected for the study by Schwab *et al.* [@pntd.0000211-Schwab1] and indicates the number of microfilariae and hosts sampled. The village of Gora was removed from the *F*-statistic analysis since only one host was sampled in this village. In some hosts it was possible to genotype only a few microfilariae, increasing the uncertainty associated with estimation of underlying infrapopulation allele frequencies in these hosts. Results are grouped according to parasite treatment history. The average frequencies of allele *Y* in microfilarial samples from untreated and treated hosts were 0.26 and 0.60, respectively [@pntd.0000211-Schwab1]. The degree of parasite heterozygosity (the proportion of microfilariae with the heterozygote genotype) is estimated for each village. The table also indicates the deviation of each population from the Hardy-Weinberg Equilibrium (HWE), which gives the proportion of heterozygote microfilariae that would be expected in a randomly mating population. This reveals a strong deficit of heterozygotes in all three populations.
+## Results so far
-10.1371/journal.pntd.0000211.t001
+### New implementation
+| Model | Size | grpsz | act | Seq. len. | VRAM | Prompt | Best | Worst | Ppl |
+|------------|-------|-------|-----|----------------------|-----------|------------|---------|---------|------|
+| Llama | 7B | 128 | no | 2,048 t | 5,194 MB | 13,918 t/s | 173 t/s | 140 t/s | 6.45 |
+| Llama | 13B | 128 | no | 2,048 t | 9,127 MB | 7,507 t/s | 102 t/s | 86 t/s | 5.60 |
+| Llama | 33B | 128 | no | 2,048 t | 20,795 MB | 2,959 t/s | 47 t/s | 40 t/s | 4.60 |
+| Llama | 33B | 128 | yes | 2,048 t | 20,795 MB | 2,784 t/s | 45 t/s | 37 t/s | 4.55 |
+| Llama | 33B | 32 | yes | 1,550 t 1 | 21,486 MB | 2,636 t/s | 41 t/s | 37 t/s | 4.52 |
+| Koala | 13B | 128 | yes | 2,048 t | 9,127 MB | 5,529 t/s | 93 t/s | 79 t/s | 6.73 |
+| WizardLM | 33B | - | yes | 2,048 t | 20,199 MB | 2,313 t/s | 47 t/s | 40 t/s | 5.75 |
+| OpenLlama | 3B | 128 | yes | 2,048 t | 3,128 MB | 16,419 t/s | 226 t/s | 170 t/s | 7.81 |
-###### Summary of the genetic survey conducted on *Wuchereria bancrofti* microfilariae from Burkina Faso of genetic changes at the β-tubulin locus associated with benzimidazole resistance (in nematodes of ruminants).
+1 Can not achieve full sequence length without OoM
-{#pntd-0000211-t001-1}
+All tests done on stock RTX 4090 / 12900K, running with a desktop environment, with a few other apps also using VRAM.
- Village No. hosts sampled Mean no. of microfilariae genotyped per host (range) Mean microfilaraemia per 20 µl blood (range) Sample (microfilarial) resistance allele frequency, Sample and \[expected\] heterozygosity
- ------------------------------------------------------------------------------ ------------------- ------------------------------------------------------ ---------------------------------------------- ----------------------------------------------------- ----------------------------------------
- Untreated villages
- TANGONKO 16 9.6 (1, 15) 323 (162, 703) 0.28 0.20 \[0.40\]
- BADONGO 14 6.6 (1, 10) 212 (60, 845) 0.23 0.24 \[0.35\]
- Village that had received one round of chemotherapy (albendazole+ivermectin)
- PERIGBAN 13 8.5 (3, 12) 35 (18, 86) 0.62 0.27 \[0.47\]
+**"Prompt"** speed is inference over the sequence length listed minus 128 tokens. **"Worst"** is the average speed for
+the last 128 tokens of the full context (worst case) and **"Best"** lists the speed for the first 128 tokens in an
+empty sequence (best case.)
-Results were presented by Schwab *et al.* [@pntd.0000211-Schwab1]. The range of microfilarial samples obtained per host is given in brackets. The expected microfilariae heterozygosity according to the Hardy-Weinberg equilibrium is given in square brackets.
+VRAM usage is as reported by PyTorch and does not include PyTorch's own overhead (CUDA kernels,
+internal buffers etc.) This is somewhat unpredictable anyway. Best bet is to just optimize VRAM usage by the model,
+probably aiming for 20 GB on a 24 GB GPU to ensure there is room for a desktop environment and all of Torch's
+internals.
-In this paper, we refer to two different types of allele frequency: (1) the underlying frequency of the allele putatively associated with BZ resistance, with *q^l^* denoting the allele frequency of the entire parasite population of a given locality, and (2) the parasite allele frequency within the host population that is sampled, denoted by *^H^q^l^*. The superscript *l* denotes the parasite life-stage under investigation, be it microfilariae (*l = M*) or adult worms (*l = W*), and *H* denotes definitive host. The allele frequency estimated from the sample, , may not correspond to the true underlying allele frequency, *q^l^*, either because the hosts sampled are not representative of the whole host population, or because the parasites genotyped do not represent adequately the allele frequency within the host.
+Perplexity is measured only to verify that the models are working. The dataset used is a particular, small sample from
+WikiText, so scores are not comparable to other Llama benchmarks and only useful for comparing the different Llama
+models to one another.
-Estimating parasite inbreeding {#s2b}
-------------------------------
+### Dual GPU results
-By genotyping transmission stages before they leave the definitive host prior to the introduction of mass chemotherapy, insight can be gained into the different causes of microfilarial excess homozygosity. If it is assumed that the number of microfilariae produced, their survival, and their probability of being sampled are independent of their genotype (as we do in the null model), it can be assumed that deviation from the HWE may be the result of non-random mating. If the locus being investigated is not under selection, the excess microfilarial homozygosity will most likely be the result of either infrapopulation genetic differentiation or non-random parasite mating within hosts. Genotyping transmission stages would allow the relative contributions of each of these two sources of inbreeding to be estimated. The variation in the allele frequency between hosts will account for some of the excess homozygosity whilst deviation from the HWE in the microfilariae within an individual host will indicate possible non-random mating within the infrapopulation.
+The following benchmarks are from a 4090 + 3090-Ti with `-gs 17.2,24`:
-The Wright\'s hierarchical *F*-statistic is used to investigate the correlation of parasite genes within and between human hosts [@pntd.0000211-Curtis1]--[@pntd.0000211-Paterson1],[@pntd.0000211-Brouwer1]. It is assumed that the infrapopulation is the first hierarchical group in the parasite population, and *F~IS~* is defined as the correlation of genes between microfilariae within the infrapopulation; , as the correlation of microfilarial genes between different hosts living in the same village; , as the correlation of microfilarial genes between different villages within the overall microfilarial population; and *F~IT~*, as the correlation of genes between individual microfilariae relative to the overall microfilarial population of the region. The different inbreeding terms introduced are summarized in [Table 2](#pntd-0000211-t002){ref-type="table"}. A value of *F~IS~* is significantly greater than zero points towards adult worm non-random mating, indicates variation in worm allele frequency between hosts, and suggests differences in the worm allele frequency between villages. The same statistical frameworks used to estimate Wright\'s *F*-statistic were employed here, taking into account variable sample sizes [@pntd.0000211-Weir1]. Estimates of the 95% confidence intervals for *F~IS~*, and *F~IT~*, were generated by bootstrapping simultaneously worms within each host and bootstrapping over hosts within each village [@pntd.0000211-Efron1]. *F-*statistics, and their associated uncertainty, were calculated for each village.
+| Model | Size | groupsize | act | Seq. len. | VRAM | Prompt | Best | Worst | Ppl |
+|---------|------|-----------|-----|----------------|-----------|-----------|--------|---------|-------|
+| Llama | 65B | 128 | yes | 2,048 t | 39,804 MB | 1,109 t/s | 20 t/s | 18 t/s | 4.20 |
+| Llama | 65B | 32 | yes | 2,048 t | 43,424 MB | 1,037 t/s | 17 t/s | 16 t/s | 4.11 |
+| Llama-2 | 70B | 128 | yes | 2,048 t | 40,680 MB | 914 t/s | 17 t/s | 14 t/s | 4.15 |
+| Llama-2 | 70B | 32 | yes | 2,048 t | 36,815 MB | 874 t/s | 15 t/s | 12 t/s | 4.10 |
-Modelling the allele frequency and genotype distribution of microfilariae {#s2c}
--------------------------------------------------------------------------
+Note that perplexity scores may not be strictly apples-to-apples between Llama and Llama 2 due to their different
+pretraining datasets.
-A dioecious adult worm helminth population with a 1:1 male to female ratio was randomly generated for a given mean number of worms per host and degree of parasite overdispersion (as determined by the *k* parameter of the negative binomial distribution, parameterized following [@pntd.0000211-Anderson2]). Each adult worm infrapopulation was randomly allocated an allele frequency, as analysis of pre-treatment data did not detect any significant relationship between the host\'s frequency of allele *Y* and microfilarial burden. The adult worm allele frequency of each host was randomly selected according to the given underlying allele frequency, *q^W^*, and the degree of parasite genetic differentiation between hosts, . For a description of a method for generating the distribution of allele frequencies in a subdivided population using the beta distribution [@pntd.0000211-Wright1], see Porter [@pntd.0000211-Porter1].
+## Todo
-It is again assumed that microfilarial production and survival is independent of genotype, allowing a microfilarial population for each host *i* to be generated according to the size and allele frequency of the adult worm infrapopulation. Worms were assumed to be polygamous; implying that if only one male parasite were present within a host, all fertile females within that infrapopulation would be mated. The number of microfilariae produced by each parasite infrapopulation was assumed to be proportional to the number of fertilised females within that host. It was also assumed that gametes separate independently and re-assort according to the degree of non-random mating (*F~IS~*). The probability with which a microfilaria within host *i*, will be of genotype *j* is denoted , and given by the equations, where and are, respectively, the frequency of allele *Y* in the male and female adult worms within host *i*, and and are the corresponding susceptible allele *F* frequencies. To allow random stochastic fluctuations in genotype distribution, the actual number of microfilariae in host *i* with genotype *j* follows a binomial distribution, with the number of trials being equal to the number of microfilariae produced by host *i*, with genotype probability equal to .
+Moved the todo list [here](doc/TODO.md).
-Microfilarial allele frequencies and genotype distributions were generated by sampling a specific number of microfilariae from the generated hypothetical population according to the sampling scheme used in Schwab *et al.* [@pntd.0000211-Schwab1]. The exact number of samples taken from each of the 30 hosts was: 11, 10, 15, 9, 11, 9, 13, 10, 10, 7, 10, 10, 7, 1, 11, 9, 1, 7, 4, 1, 10, 9, 8, 6, 4, 6, 9, 10, 10, 8, for a total of 246 microfilariae. Analysis of pre-treatment data had indicated that the number of samples taken from each host by Schwab *et al.* [@pntd.0000211-Schwab1] was independent of host microfilaraemia and host allele frequency, allowing the number of microfilariae sampled per host to be randomly allocated. The program code for the simulations implemented was written in C++ and run 100,000 times, with each run generating a new helminth population and genotype distribution from which 95% confidence limits (95% CL) were calculated.
+## Compatibility
-The model was parameterised for the untreated villages of Tangonko and Badongo, Burkina Faso, which had an initial prevalence of microfilaraemia of 25%. The mean adult worm burden was estimated from observed microfilarial counts using the functional relationship given in the deterministic model EPIFIL (see original formulation and parameter values in Norman *et al*. [@pntd.0000211-Norman1]), giving a mean adult worm burden of 13.5 host^−1^. The degree of adult worm overdispersion was estimated from the recorded microfilarial prevalence (taken here as a proxy for the prevalence of adult worms producing microfilariae) and the mean adult worm burden, using the prevalence vs. intensity relationship that derives from assuming a negative binomial distribution of worms among hosts [@pntd.0000211-Anderson2], yielding a *k* value of 0.07. The model outlined above will only be valid for comparisons against the pre-treatment data, since chemotherapy is known to impede microfilarial production and / or survival [@pntd.0000211-Tisch1].
+[Here](doc/model_compatibility.md) is a list of models confirmed to be working right now.
-The null model assumes that mating is random between male and female worms within each infrapopulation and that allele *Y* is randomly distributed across hosts, i.e. . Results of the inbreeding analysis can be incorporated into the individual-based model described in equations (1) to (3) to explore the range of adult worm allele frequencies which can give rise to the observed microfilarial data.
-Results {#s3}
-=======
+import * as util from "./util.js";
+import * as mainmenu from "./mainmenu.js";
+import * as globals from "./globals.js";
+import * as controls from "./controls.js";
+import * as overlay from "./overlay.js";
-The observed microfilarial genotype distribution was found to deviate from HWE. Villages with no history of mass anthelmintic chemotherapy had an overall inbreeding coefficient of *F~IT~* = 0.44 (95% CL = 0.17, 0.68), indicating strong inbreeding. Fifteen percent of the microfilariae were found to be homozygous for allele *Y*, an estimate 2.3 times higher than would be expected in a random mating parasite population. Results indicate the occurrence of a significant degree of genetic differentiation in worm allele frequency among the host population . Infrapopulation allele *Y* frequency, , varied from 0 to 0.77 in the villages with no history of treatment, indicating an increase in microfilarial homozygosity of 60% above HWE. The results also suggest a degree of non-random mating within hosts measured by *F~IS~* = 0.29 (−0.09, 0.54), which is however is not significantly greater than zero. No difference was observed in the microfilarial allele frequency between the two treatment-naïve villages .
+export class NotepadSettings {
+ constructor(parent) {
+ this.element = util.newHFlex();
+ this.parent = parent;
+ this.settings = this.parent.notepadSettings;
+ //console.log(this.settings);
+ this.populate();
+ }
-The data from the two treatment-naïve villages of Tangonko and Badongo were analysed separately. Both showed a high level of microfilarial homozygosity, with overall inbreeding coefficient of *F~IT~* = 0.51 (0.16, 0.76) and *F~IT~* = 0.33 (−0.10, 0.78), respectively ([Figure 1](#pntd-0000211-g001){ref-type="fig"}). The degree of parasite genetic differentiation between hosts varied between the two villages, though the difference was not statistically significant (*p* = 0.38, calculated from the square of the normalized difference in *F~ST~* estimates [@pntd.0000211-Little1]). For the purpose of the following analysis the two treatment-naïve villages have been grouped together to increase the study sample size. A similar degree of parasite inbreeding was observed in the village of Perigban which had received one round of MDA.
+ populate() {
+ this.element.innerHTML = "";
-{#pntd-0000211-g001}
+ this.sss_genParams = new controls.CollapsibleSection(null, "Generation parameters");
+ this.sss_sampling = new controls.CollapsibleSection(null, "Sampling");
+ this.element.appendChild(this.sss_genParams.element);
+ this.element.appendChild(this.sss_sampling.element);
-Parasite inbreeding increases the range of underlying adult worm allele *Y* frequencies, *q^W^*, which can give rise to the observed microfilarial allele *Y* frequency of 0.26 ([Figure 2](#pntd-0000211-g002){ref-type="fig"}). Results from the null model, where mating was assumed to be random and allele *Y* is randomly distributed amongst hosts, indicate that *q^W^* in the untreated villages of Tangonko and Badongo could range from 0.21 to 0.32. If we use the excess inbreeding estimate reported in pre-treatment villages (*F~IT~* = 0.44), then model simulations suggest that *q^W^* could range from 0.18 to 0.37.
+ // Generation params
-![The impact of inbreeding on the relationship between the sample microfilarial allele frequencies, , and the (inferred) underlying adult worm allele frequency, *q^W^*, for the substitution at codon 200 of the β-tubulin gene in *W. bancrofti*.\
-The figure shows 95% confidence intervals for a population with no excess inbreeding (the null model, dark grey shaded area), and a population with the observed levels of inbreeding (*F~IS~* = 0.28, , light grey shaded area). Simulations are based on the same sampling scheme used in Burkina Faso [@pntd.0000211-Schwab1]. The thick black solid line indicates the mean result for both models. The observed pre-treatment microfilarial allele frequency (; black thin, horizontal dotted line) was compared to simulation results to indicate the possible range of adult worm allele frequencies which could have given rise to the West African data. The null model (black vertical dotted-dashed lines) indicated values of *q^W^* ranging from 0.21 to 0.32 compared to the inbred model (*F~IS~* = 0.28, , black vertical dashed lines), which gave values of *q^W^* between 0.18 and 0.37.](pntd.0000211.g002){#pntd-0000211-g002}
+ this.sss_i_maxTokens = new controls.SettingsSlider("sss-item-left", "Max tokens", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 16, 2048, null, this.settings, "maxtokens", () => { this.updateView(true); });
+ this.sss_i_chunkTokens = new controls.SettingsSlider("sss-item-left", "Chunk tokens", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 16, 2048, null, this.settings, "chunktokens", () => { this.updateView(true); });
+ this.sss_stopConditions = new controls.CollapsibleSection(null, "Stop conditions");
+ this.sss_genParams.inner.appendChild(this.sss_i_maxTokens.element);
+ this.sss_genParams.inner.appendChild(this.sss_i_chunkTokens.element);
+ this.element.appendChild(this.sss_stopConditions.element);
-The microfilarial genotype diversity model indicates that the observed homozygosity is unlikely to be solely a result of genetic sampling, demographic stochasticity, population subdivision, or the sampling scheme employed, suggesting that true biological mechanisms are operating in the parasite population even before the introduction of anthelmintic therapy. [Figure 2](#pntd-0000211-g002){ref-type="fig"} indicates the range of likely microfilarial genotype distributions that can be generated from a given *q^W^* value using the null (random) model. The observed excess homozygosity in the untreated villages was greater than the 95% confidence interval estimates generated by the null model ([Figure 3](#pntd-0000211-g003){ref-type="fig"}). It is interesting to note the wide range of microfilarial genotype distributions that can be generated by the null model.
+ // Sampling
-![De Finetti diagram showing the genotype distribution of *W. bancrofti* microfilariae generated from a given underlying adult worm allele frequency, *q^W^*, taken from villages prior to the introduction of chemotherapy.\
-A full explanation of the De Finetti diagram is given in [@pntd.0000211-Hartl1]. The black diamond represents the value originating from the observed data (with , and *F~IT~* = 0.44), and the error bars indicate the uncertainty in genotype distribution stemming from the values of *q^W^* (0.21, 0.32) that were estimated from the null (random) model ([Figure 2](#pntd-0000211-g002){ref-type="fig"}). Y indicates the allele coding for tyrosine at position 200 of β-tubulin that is associated with benzimidazole (BZ) resistance in nematodes of livestock, and F denotes the allele (coding for phenylalanine) indicative of BZ susceptibility. The solid-black curve represents the Hardy-Weinberg equilibrium (HWE). The null model generating microfilarial allele frequencies (see text) was used to investigate the range of sample microfilarial genotype distributions that could be obtained from a population exhibiting no excess inbreeding (i.e. assuming that the underlying adult parasite population would have values of ). Simulations mimic the same sampling scheme described in Schwab *et al*. The observed microfilarial genotype distribution falls outside the 95% confidence interval range (grey shaded area surrounding the HWE curve) generated by the null model, despite the uncertainty in the underlying *q^W^* estimates, indicating strong parasite inbreeding even before introduction of antifilarial combination therapy.](pntd.0000211.g003){#pntd-0000211-g003}
+ this.sss_i_temperature = new controls.SettingsSlider("sss-item-left", "Temperature", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 3, null, this.settings, "temperature", () => { this.updateView(true); });
+ this.sss_i_topK = new controls.SettingsSlider("sss-item-left", "Top K", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 0, 1000, { "0": "off" }, this.settings, "top_k", () => { this.updateView(true); });
+ this.sss_i_topP = new controls.SettingsSlider("sss-item-left", "Top P", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "top_p", () => { this.updateView(true); });
+ this.sss_i_minP = new controls.SettingsSlider("sss-item-left", "Min P", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "min_p", () => { this.updateView(true); });
+ this.sss_i_tfs = new controls.SettingsSlider("sss-item-left", "TFS", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "tfs", () => { this.updateView(true); });
+ this.sss_i_typical = new controls.SettingsSlider("sss-item-left", "Typical", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0, 1, { "0.00": "off", "1.00": "off" }, this.settings, "typical", () => { this.updateView(true); });
+ this.sss_i_repPenalty = new controls.SettingsSlider("sss-item-left", "Rep. penalty", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 1, 3, { "1.00": "off" }, this.settings, "repp", () => { this.updateView(true); });
+ this.sss_i_repRange = new controls.SettingsSlider("sss-item-left", "Rep. range", "sss-item-mid", "sss-item-right sss-item-textbox-r", 0, 0, 4096, { "0": "off" }, this.settings, "repr", () => { this.updateView(true); });
-Despite the large increase in microfilarial homozygosity attributable to parasite inbreeding, there is only a modest increase in the prevalence of hosts who have microfilariae that are homozygous for allele *Y* (and therefore putatively resistant if the allele confers drug resistance were recessive, [Figure 4](#pntd-0000211-g004){ref-type="fig"}). Parasite overdispersion reduces the number of hosts who are microfilaria-positive and concentrates allele *Y* into a small proportion of the host population. A high degree of parasite non-random mating and infrapopulation genetic differentiation increases the number of hosts (and the number of samples per host) that need to be sampled, in order to detect or quantify reliably parasite genetic diversity ([Figure 4](#pntd-0000211-g004){ref-type="fig"}). The model is used to investigate how parasite inbreeding may influence the sampling scheme of genetic surveys seeking to identify the presence of a known marker for drug resistance ([Figure 5](#pntd-0000211-g005){ref-type="fig"}). Results indicate that the observed level of parasite inbreeding markedly increases the minimum number of hosts, and the overall number of samples necessary to be 95% confident of detecting a rare allele. The sampling scheme used within [Figure 5](#pntd-0000211-g005){ref-type="fig"} assumes that the number of parasites genotyped per host is weighted by the host\'s microfilarial load. This improves the accuracy of allele frequency estimates by allowing heavily infected hosts to have a greater contribution to the sampled microfilarial population, something which is particularly important in overdispersed parasite populations.
+ this.sss_i_mirostat = new controls.CheckboxLabel("sss-item-right clickable", "Mirostat", this.settings, "mirostat", () => { this.updateView(true); });
+ this.sss_i_mirostat_tau = new controls.SettingsSlider("sss-item-left", "Mirostat tau", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0.01, 10, null, this.settings, "mirostat_tau", () => { this.updateView(true); });
+ this.sss_i_mirostat_eta = new controls.SettingsSlider("sss-item-left", "Mirostat eta", "sss-item-mid", "sss-item-right sss-item-textbox-r", 2, 0.01, 5, null, this.settings, "mirostat_eta", () => { this.updateView(true); });
-![The impact of inbreeding on the relationship between the mean proportion of hosts harbouring microfilariae with one or two copies of allele *Y* and the (assumed) underlying adult worm allele frequency, *q^W^.*\
-The figure compares the proportion of hosts exhibiting microfilariae with allele *Y* (i.e. both heterozygous and homozygous *YY* microfilariae, solid lines) with that of hosts which have only microfilariae with the homozygous *YY* genotype (broken lines). Model outcomes are compared for two hypothetical parasite populations; the former (thin grey lines) without excess inbreeding (generated by the null model), and the latter (thick black lines) with the levels of inbreeding (*F~IS~* = 0.28, ) observed in the Burkina Faso data. Simulations used the same sampling scheme described in Schwab *et al.* [@pntd.0000211-Schwab1] and assume an overall microfilarial prevalence of ∼25% (see text).](pntd.0000211.g004){#pntd-0000211-g004}
+ this.sss_sampling.inner.appendChild(this.sss_i_temperature.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_topK.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_topP.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_minP.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_tfs.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_typical.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_repPenalty.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_repRange.element);
-{#pntd-0000211-g005}
+ this.sss_sampling.inner.appendChild(this.sss_i_mirostat.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_mirostat_tau.element);
+ this.sss_sampling.inner.appendChild(this.sss_i_mirostat_eta.element);
-To date there is no phenotypic evidence that allele *Y* causes albendazole resistance in *W. bancrofti*. However, if an allele conferring drug resistance existed in populations of this parasite then the consequences on the spread of such an allele of parasite non-random mating and genetic differentiation between hosts will depend on the frequency and the relative dominance of the resistance allele. If the resistance allele were recessive, helminth inbreeding would greatly increase the probability that a parasite survives anthelmintic treatment. This is evident from [Figure 6](#pntd-0000211-g006){ref-type="fig"} which shows the influence of parasite inbreeding on the relative proportion of resistant genotypes for a given allele frequency. With a recessive resistance allele at a frequency of 0.05, the degree of inbreeding within the *W. bancrofti* population reported here, would on average increase the number of worms with the homozygote resistance genotype nine-fold. Conversely, if the resistance allele was dominant, inbreeding would reduce the probability that a parasite survives chemotherapy, as fewer worms would have the resistant allele (the deficiency of heterozygous parasites caused by parasite inbreeding will be greater than the increase in resistant homozygous worms).
+ // Stop conditions
-{ref-type="fig"}: mean result (*F~IT~* = 0.44, solid line); upper 95% confidence limit (*F~IT~* = 0.68, dashed line); lower 95% confidence limit (*F~IT~* = 0.17, dotted line). The relative change in the number of resistant genotypes caused by parasite inbreeding is estimated as in (A) and in (B).](pntd.0000211.g006){#pntd-0000211-g006}
+ this.populate_stop_conditions();
-10.1371/journal.pntd.0000211.t002
+ this.updateView();
+ }
-###### The extension of Wright\'s *F*-statistic to represent the hierarchical population structure of obligate parasites of humans, exemplified in this paper with *Wuchereria bancrofti* (adapted from [@pntd.0000211-Hartl1] and [@pntd.0000211-Weir1]).
+ populate_stop_conditions() {
+ this.sss_stopConditions.inner.innerHTML = "";
+ this.sss_i_stopconditions = [];
+
+ for (let i = 0; i < this.settings.stop_conditions.length; i++) {
+ this.sss_i_stopconditions[i] = new controls.CheckboxTextboxButton(
+ "stop_condition_" + i,
+ "sss-item-left",
+ "Incl.",
+ "sss-item-mid sss-item-textbox",
+ "",
+ this.settings,
+ "stop_conditions",
+ i,
+ "text",
+ "inclusive",
+ (v) => { return v != ""; },
+ () => { this.updateView(true); },
+ "✕ Remove",
+ () => {
+ this.settings.stop_conditions.splice(i, 1);
+ this.populate_stop_conditions();
+ this.updateView(true);
+ }
+ );
+ }
-{#pntd-0000211-t002-2}
+ for (let i = 0; i < this.settings.stop_conditions.length; i++)
+ this.sss_stopConditions.inner.appendChild(this.sss_i_stopconditions[i].element);
- Symbol Definition
- --------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- *F~IT~* Correlation of alleles within individual worms relative to alleles drawn at random from the overall worm population (total deviation from the Hardy-Weinberg Equilibrium)
- *F~IS~* Correlation of alleles within individual worms relative to alleles drawn at random from the parasite infrapopulation (within host non-random mating)
- Correlation of parasite alleles within parasite infrapopulations relative to alleles drawn at random from parasites within the same village (parasite genetic differentiation between hosts within villages)
- Correlation of parasite alleles within a village relative to alleles drawn at random from the overall worm population (parasite genetic differentiation between villages)
+ if (this.settings.stop_conditions.length < 10) {
+ this.sss_i_addStopCondition = new controls.LinkButton("+ Add...", null, () => {
+ this.settings.stop_conditions.push({text: "", inclusive: false});
+ this.populate_stop_conditions();
+ this.updateView(true);
+ }, "sss-item-link");
+ this.sss_stopConditions.inner.appendChild(this.sss_i_addStopCondition.element);
+ }
+ }
-The table includes a graphical representation of the different *F*-statistics.
+ updateView(send = false) {
-Discussion {#s4}
-==========
+ // Settings visibility
-The genotype distribution of *W. bancrofti* microfilariae varied dramatically from the HWE prior to the introduction of MDA. The degree of excess homozygosity reported falls outside the range of values generated by the null model described in this paper, indicating a significant degree of parasite non-random mating. This may be caused, in part, by parasite genetic differentiation between hosts. The null model generates a wide range of microfilarial allele frequencies and genotype distributions indicating that caution should be exercised when interpreting results obtained by sampling solely transmission stages. Significant changes in the genetic diversity of microfilarial populations over time may not reflect a significant change in the underlying adult worm population. This result highlights the crucial importance of developing sound theoretical null models that enable helminth population genetics data to be interpreted adequately [@pntd.0000211-Prugnolle2]. These models should take into account the uncertainty in outcomes, given the sampling scheme employed and the life-history traits of the parasite. A combination of sampling transmission stages and parasite inbreeding could cause estimates of the underlying adult worm allele frequency to be highly variable, increasing the number of samples that need to be genotyped in order to detect significant changes in the adult worm genome with time after introduction of chemotherapeutic pressure.
+ let mirostat = this.settings.mirostat;
+ this.sss_i_mirostat_tau.setVisible(mirostat);
+ this.sss_i_mirostat_eta.setVisible(mirostat);
-Producing a null model to assess the range of adult worm allele frequencies that could give rise to the microfilarial genetic diversity observed in villages having received treatment is complex and beyond the scope of this paper. A dynamic, full transmission model would be required that takes into account the pharmacodynamic properties of the drugs in combination and separately, as the effects of chemotherapy will influence microfilarial genetic diversity for a number of years after chemotherapy. As a result it is not possible to conclude whether adult worm genetic diversity differs between the villages that have and have not received MDA, even though their microfilarial populations differ significantly in their genetic diversity.
+ // Send
-The results presented within this paper regarding the metapopulation dynamics of bancroftian filariasis stem from the analysis of a single nucleotide polymorphism in one gene. Further surveys, using multiple neutral polymorphic loci, are required to distinguish demographic and sampling effects from selective pressures [@pntd.0000211-Weir1]. If the allele of interest has been under selection then the observed genotype distribution could have been generated without the need for non-random parasite mating. The accuracy of the model developed here to derive microfilarial genetic diversity is limited by uncertainties regarding the biology of *W. bancrofti*. Results are dependent on our current ability to mimic adult worm burden and its distribution among hosts. Limitations inherent in the EPIFIL model, the presence of amicrofilaraemic yet circulating filarial antigen-positive infections, and possible heterogeneity in host immune responses could make adult worm burden estimates highly uncertain from microfilarial prevalence and intensity data. The relationship between the number of adult filariae and the rate of microfilarial production is likely to be complex and may depend on the immune responses elicited during the infection. The null model assumes a mean parasite intensity of 13.5 adult worms per host, though sensitivity analysis indicated that model results were relatively insensitive to small changes in parasite intensity around this value (sensitivity analysis ranged from 8.5 to 18.5 adult worms host^−1^, results not shown). Our conclusions are based on the adequacy of the null model, which may be improved by the inclusion of further biological detail. For example, recent evidence suggests a possible association between β-tubulin genotype in the related filarial parasite, *Onchocerca volvulus*, and female worm fertility [@pntd.0000211-Bourguinat1],[@pntd.0000211-Bourguinat2], suggesting a cost of resistance. Whilst the same gene has been analyzed in the current study, it is not known whether a similar relationship between genotype and fertility applies to *W. bancrofti*. If this were the case then the conclusions drawn regarding the causes of the observed genotype distribution should be treated with caution. Although no differences were seen in genotype frequency between the two pre-treatment villages studied, additional baseline surveys (prior to the start of MDA) would be required before firm conclusions regarding the true underlying frequency of allele *Y* in pre-treatment *W. bancrofti* populations can be drawn.
+ if (send) this.send();
+ //console.log(this.settings);
+ }
-Notwithstanding the fact that the *F*-statistic provides a phenomenological tool rather than a mechanistic measure of inbreeding (and therefore does not describe the biological processes generating excess homozygosity), we proceed to propose some likely causes for the strong degree of non-random mating identified in *W. bancrofti*, as well as the implications that this may have for the development and detection of anthelmintic resistance.
+ send(post = null) {
+ //console.log(this.settings);
+
+ let packet = {};
+ packet.settings = this.settings;
+ if (!this.parent.notepadID || this.parent.notepadID == "new") {
+ fetch("/api/new_notepad", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(packet) })
+ .then(response => response.json())
+ .then(response => {
+ this.parent.parent.lastNotepadUUID = response.notepad.notepad_uuid;
+ this.parent.parent.onEnter();
+ if (post) post(response);
+ });
+ } else {
+ fetch("/api/update_notepad_settings", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(packet) })
+ .then(response => response.json())
+ .then(response => {
+ if (post) post(response);
+ });
+ }
+ }
-Non-random infrapopulation mating {#s4a}
----------------------------------
-Our results suggest that adult *W. bancrofti* worms do not mate randomly within the infrapopulation. This is in agreement with ultrasonography studies that show adult parasites congregating in 'worm nests' along lymphatic vessels, which remain stable over time [@pntd.0000211-Dreyer1]. Spatial heterogeneity within the host may produce multiple reproducing populations within each infrapopulation, which would increase host microfilarial homozygosity. Evidence of an apparent relationship between β-tubulin genotype, the same gene analyzed by Schwab *et al.* [@pntd.0000211-Schwab1], and female worm fertility in the related filaria *O. volvulus* has been reported by Bourguinat *et al.* [@pntd.0000211-Bourguinat2]. If such a relationship exists in *W. bancrofti*, the excess within-host homozygosity reported above may result from the increased fertility of homozygous adult worms. Anthelmintic treatment, prior to the introduction of MDA for lymphatic filariasis, may also have increased non-random mating depending on the selective advantage that allele *Y* may confer to the parasite at the time of treatment.
-Parasite genetic differentiation between hosts {#s4b}
-----------------------------------------------
+}
-The degree of genetic differentiation in the parasite infrapopulation can shed insight into the microepidemiology of parasite transmission [@pntd.0000211-Anderson1]--[@pntd.0000211-Thron1]. The metapopulation transmission dynamics of *W. bancrofti* will depend on the transmission efficiency and biting behaviour of the mosquito vector. *Anopheles gambiae sensu stricto* and *An. funestus* are thought to be the main vectors of *W. bancrofti* in Burkina Faso [@pntd.0000211-Gyapong1]. Hosts can acquire multiple L3 larvae during the same bite. Although density-dependent processes are known to operate on the uptake and development of *W. bancrofti* in *An. gambiae*, infective vectors will regularly transmit multiple related L3 larvae simultaneously [@pntd.0000211-Snow1]. Other mosquito vectors of *W. bancrofti* have even greater vector competence. For example, up to 32 L3 larvae were recovered from an experimental host after it was bitten by a single *Culex quinquefasciatus* [@pntd.0000211-Gasarasi1], a main vector in East Africa. Mark-recapture studies and bloodmeal analysis indicate that various mosquito species appear to have high site fidelity, regularly biting multiple members of the same household [@pntd.0000211-McCall1],[@pntd.0000211-Michael1]. These aspects of *W. bancrofti* transmission increase the likelihood that a host will be infected with closely related parasites and will contribute to the observed genetic differentiation.
-More generally, drug treatment may increase infrapopulation genetic heterogeneity, as those parasites within treated hosts which survive treatment may have a higher resistance allele frequency than those harboured within untreated hosts. In Burkina Faso, lymphatic filariasis is treated with albendazole and ivermectin. Evidence indicates that the albendazole plus ivermectin combination has some macrofilaricidal and reproductive effects (mainly associated with albendazole [@pntd.0000211-Tisch1]), as well as the microfilaricidal effect (mainly associated with ivermectin). It is possible that a degree of the genetic differentiation between hosts observed in the untreated villages may have resulted from individual members of the community seeking, for instance, treatment for geohelminth infection prior to the introduction of GPELF.
+input[type=range] {
+ -webkit-appearance: none;
+ margin: 4px 0;
+ width: 100%;
+ background: transparent;
+}
+input[type=range]:focus {
+ outline: none;
+}
+input[type=range]::-webkit-slider-runnable-track {
+ width: 100%;
+ height: 6.4px;
+ cursor: pointer;
+ box-shadow: 1px 1px 1px #00000020, 0px 0px 1px #0d0d0d40;
+ background: var(--slider-track-color);
+ border-radius: 1.0px;
+ border: 0.2px solid #01010120;
+}
+input[type=range]::-webkit-slider-thumb {
+ box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
+ border: 1px solid #00000080;
+ height: 16px;
+ width: 16px;
+ border-radius: 3px;
+ background: var(--slider-thumb-color);
+ cursor: pointer;
+ -webkit-appearance: none;
+ margin-top: -5px;
+}
+input[type=range]:hover::-webkit-slider-runnable-track {
+ /* background: var(--slider-hover-color);*/
+}
+input[type=range]::-moz-range-track {
+ width: 100%;
+ height: 4.4px;
+ cursor: pointer;
+ box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
+ background: var(--slider-track-color);
+ border-radius: 1.3px;
+ border: 0.2px solid var(--slider-track-color);;
+}
+input[type=range]::-moz-range-thumb {
+ box-shadow: 1px 1px 1px #00000080, 0px 0px 1px #0d0d0d40;
+ border: 1px solid #00000080;
+ height: 13px;
+ width: 13px;
+ border-radius: 3px;
+ background: var(--slider-thumb-color);
+ cursor: pointer;
+}
+input[type=range]:hover::-moz-range-track {
+ /* background: var(--slider-hover-color);*/
+}
-The spread of anthelmintic resistance {#s4c}
--------------------------------------
+import * as util from "./util.js";
-Population subdivision and non-random mating will influence the outcomes of selection under chemotherapeutic pressure in different ways, depending on the initial frequency of the allele under selection and the ecology of the infection. Before the rate of spread of drug resistant parasites can be predicted reliably and accurately, greater knowledge would be required regarding the number, linkage, dominance, and possible negative pleiotropic effects of putative resistance allele(s), as well as regarding the pharmacodynamic properties of the drugs administered singly and in combination. However, useful biological insights can be obtained from mathematical models that make reasonable assumptions concerning the above [@pntd.0000211-Schwab2],[@pntd.0000211-Schwab3].
+class PageOverlay {
+ constructor() {
+ this.keyboardDisabled = false;
+ document.addEventListener("keydown", (e) => {
+ if (this.keyboardDisabled) e.preventDefault();
+ });
-If the resistance allele is recessive and it has a low initial frequency, inbreeding will increase parasite homozygosity and as a result, the spread of drug resistant worms across the parasite population (see [Figure 6](#pntd-0000211-g006){ref-type="fig"} and [@pntd.0000211-Schwab2]). If drug resistance is a semi-dominant trait then parasite inbreeding will either increase or decrease the spread of drug resistance, depending on the efficacy of the drug against heterozygote parasites. Parasite genetic differentiation between hosts will also increase the spread of resistance even when the resistance allele is initially present at a very low frequency, as it increases the probability that male and female resistant worms will inhabit the same infrapopulation. This work is consistent with mathematical models of veterinary helminths which indicate that spatial heterogeneity and aggregated infections between hosts increase the spread of rare recessive genes [@pntd.0000211-Cornell1],[@pntd.0000211-Smith1].
+ this.overlayElement = util.newDiv(null, "page-overlay");
+ document.body.appendChild(this.overlayElement);
-The detection of anthelmintic resistance {#s4d}
-----------------------------------------
+ this.items = new Map();
+ }
-The operation of a strong degree of parasite genetic differentiation between hosts reduces the prevalence of infection with drug resistant parasites and would therefore increase the number of hosts and parasites that should be sampled to detect and quantify the frequency of resistance-conferring alleles reliably. Even at high resistance allele frequencies, some hosts will have no phenotypic signs of resistance, particularly if the resistance allele is recessive, and therefore hosts respond to treatment. In practice the number of parasites that can be genotyped will be restricted, so surveys should carefully consider the sampling scheme they employ in order to maximise the accuracy of allele frequency estimates. Repeatedly sampling from the same host increases the chance of detecting a resistance mutation if it is present in that infrapopulation. However, sampling transmission stages from as many hosts as possible should be considered the optimum strategy, even in a population with low parasite genetic differentiation between hosts, as it reduces the chance of repeatedly sampling offspring of the same adult worm. Prior to the introduction of chemotherapy, studies investigating the presence and frequency of putative resistance markers through genotyping transmission stages alone should weight the number of samples they take per host by the host\'s infection intensity. However, after the start of chemotherapy the best sampling scheme will depend on the pharmacodynamics of the drug and the nature of the questions under investigation.
+ add(mode, control) {
+ this.items.set(mode, control);
+ this.overlayElement.appendChild(control.element);
+ return control;
+ }
-Parasite elimination {#s4e}
---------------------
+ setMode(mode = null) {
+ if (!mode) {
+ this.keyboardDisabled = false;
+ this.overlayElement.style.display = "none";
+ this.items.forEach((v, k) => { v.setVisible(false); });
+ } else {
+ this.keyboardDisabled = true;
+ this.overlayElement.style.display = "flex";
+ this.items.forEach((v, k) => { v.setVisible(mode === k); });
+ }
+ }
+}
-For human helminth infections, the importance of parasite genetic differentiation between hosts stretches beyond population genetics and will influence the outcomes of parasite elimination campaigns such as the GPELF. The ability of a parasite species to persist in a host population following prolonged MDA will depend in part on the metapopulation dynamics of helminth transmission, the patterns of host compliance with treatment regimes and the pharmacodynamic properties of the drugs used. The aggregated nature of the passage of transmission stages between hosts will make parasite elimination harder to achieve by lowering the breakpoint density (the unstable equilibrium below which the parasite population will tend naturally to local extinction [@pntd.0000211-Macdonald1]), as overdispersion of parasites will result in fewer hosts with a single-sexed infection.
+class Overlay {
+ constructor() {
+ this.element = util.newDiv(null, "overlay");
+ }
-The authors have declared that no competing interests exist.
+ setVisible(visible) {
+ this.element.style.display = visible ? "flex" : "none";
+ }
+}
-TSC and M-GB would like to thank the Medical Research Council, United Kingdom, for financial support. AES and RKP thank GlaxoSmithKline, FQRNT, and the Centre for Host Parasite Interactions, Québec, for financial support. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.
+class BusyOverlay extends Overlay {
+ constructor() {
+ super();
+ this.element.innerHTML = "" +
+ "";
+ }
+}
-[^1]: Analyzed the data: TC. Contributed reagents/materials/analysis tools: AS RP. Wrote the paper: TC MB.
+class LoadingOverlay extends Overlay {
+ constructor() {
+ super();
+ this.element.innerHTML = "";
-
-
-
-
-
-
-
-
-Natural killer cell cytotoxicity and alpha-interferon in early rheumatoid arthritis.
-Natural killer (NK) cell number, cytotoxicity, and serum alpha-interferon (alpha-IFN) was measured in a group of early synovitis patients and compared to that of established rheumatoid arthritis patients and normal controls. No significant differences in NK cell number or serum alpha-IFN were found. NK cell cytotoxicity (NKCC) in the early synovitis group was significantly (p < 0.05) reduced compared to that of the normal controls and not significantly different from the established rheumatoid controls. There was a trend for those early synovitis patients with a good outcome to have higher NKCC. Low NKCC is evident very early in the course of rheumatoid arthritis and is thus unlikely to be secondary to chronic inflammation. There is no relationship between NKCC and alpha-IFN levels and the cause of the reduced NKCC is unknown. Alpha-IFN levels are not raised early in the course of RA.
-France Clear Favorite on 2022 World Cup Odds
+ this.box = util.newDiv(null, "progressbar-box");
+ this.element.appendChild(this.box);
-The 2018 FIFA World Cup came to a conclusion on Sunday as France posted a 4-2 victory over Croatia to claim their second World Cup title in 20 years and pay out on +700 pre-tournament World Cup championship odds.
+ this.bar = util.newDiv(null, "progressbar-bar");
+ this.box.appendChild(this.bar);
+ }
-Sunday’s victory as +110 favorites on the World Cup game line odds continues France’s torrid play at recent international tournaments. Les Bleus came within an extra time goal of the Euro 2016 championship, falling to Portugal by a 1-0 score in their only defeat at a major international tournament since the quarter-finals of the 2014 World Cup.
+ setProgress(a, b) {
+ let percentage = 100 * (a / b);
+ this.bar.style.width = percentage + '%';
+ }
+}
-With a youthful lineup led by 19-year-old Kylian Mbappe, who garnered Best Young Player Award honors at this year’s tournament, France’s future looks bright. Fresh off the heels of their victory this weekend, Les Bleus opened as clear +500 favorites to successfully defend their title on the 2022 World Cup odds.
+export var pageOverlay = new PageOverlay();
+export var busyOverlay = pageOverlay.add("busy", new BusyOverlay());
+export var loadingOverlay = pageOverlay.add("loading", new LoadingOverlay());
+
+
+
+@app.route("/api/load_model", methods=['POST'])
+def api_load_model():
+ global api_lock, verbose
+ if verbose: print("/api/load_model")
+ with api_lock:
+ data = request.get_json()
+ if verbose: print("<-", data)
+ if verbose: print("-> ...")
+ result = Response(stream_with_context(load_model(data)), mimetype = 'application/json')
+ if verbose: print("->", result)
+ return result
+
+@app.route("/api/unload_model")
+def api_unload_model():
+ global api_lock, verbose
+ if verbose: print("/api/unload_model")
+ with api_lock:
+ result = unload_model()
+ if verbose: print("->", result)
+ return json.dumps(result) + "\n"
+
+@app.route("/api/list_sessions")
+def api_list_sessions():
+ global api_lock, verbose
+ if verbose: print("/api/list_sessions")
+ with api_lock:
+ s, c = list_sessions()
+ result = { "result": "ok", "sessions": s, "current_session": c }
+ if verbose: print("-> (...)")
+ return json.dumps(result) + "\n"
+
+@app.route("/api/get_default_settings")
+def api_get_default_settings():
+ global api_lock, verbose
+ if verbose: print("/api/get_default_settings")
+ with api_lock:
+ result = { "result": "ok",
+ "session_settings": get_default_session_settings(),
+ "notepad_settings": get_default_notepad_settings(),
+ "prompt_formats": list_prompt_formats() }
+ return json.dumps(result) + "\n"
+
+@app.route("/api/set_session", methods=['POST'])
+def api_set_session():
+ global api_lock, verbose
+ if verbose: print("/api/set_session")
+ with api_lock:
+ data = request.get_json()
+ if verbose: print("<-", data)
+ session = set_session(data)
+ if session is not None:
+ result = { "result": "ok",
+ "session": session,
+ "prompt_formats": list_prompt_formats() }
+ if verbose: print("-> (...)")
+ else:
+ result = { "result": "fail" }
+ if verbose: print("->", result)
+ return json.dumps(result) + "\n"
+
+@app.route("/api/new_session", methods=['POST'])
+def api_new_session():
+ global api_lock, verbose
+ if verbose: print("/api/new_session")
+ with api_lock:
+ data = request.get_json()
+ if verbose: print("<-", data)
+ session = new_session()
+ if "settings" in data: get_session().update_settings(data["settings"])
+ if "user_input_text" in data: get_session().user_input(data)
+ if "new_name" in data: get_session().rename(data)
+ result = { "result": "ok", "session": session }
+ if verbose: print("-> (...)")
+ return json.dumps(result) + "\n"
+
+@app.route("/api/rename_session", methods=['POST'])
+def api_rename_session():
+ global api_lock, verbose
+ if verbose: print("/api/rename_session")
+ with api_lock:
+ data = request.get_json()
+ if verbose: print("<-", data)
+ s = get_session()
+ s.rename(data)
+ result = { "result": "ok" }
+ if verbose: print("->", result)
+ return json.dumps(result) + "\n"
+
+
+
+def is_rocm_installed():
+ # Implement a check for ROCm (e.g., looking for specific files or running a command)
+ # Return True if ROCm is found, False otherwise
+ pass
+
+def is_cuda_installed():
+ # Implement a check for CUDA
+ # Return True if CUDA is found, False otherwise
+ pass
+
+def install_packages():
+ if is_rocm_installed():
+ subprocess.run([sys.executable, '-m', 'pip', 'install', 'some_rocm_package'])
+ elif is_cuda_installed():
+ subprocess.run([sys.executable, '-m', 'pip', 'install', 'some_cuda_package'])
+ else:
+ print("Neither ROCm nor CUDA detected.")
+
+if __name__ == "__main__":
+ install_packages()
+
+
+
+#ifndef _qdq_4_cuh
+#define _qdq_4_cuh
+
+#include "qdq_util.cuh"
+#include "../../config.h"
+
+#if QMODE_4BIT == 1
+
+// Permutation:
+//
+// 77775555 33331111 66664444 22220000
+
+__forceinline__ __device__ void shuffle_4bit_8
+(
+ uint32_t* q,
+ int stride
+)
+{
+ uint32_t qa = q[0];
+ uint32_t qb = 0;
-While Sunday’s loss as +300 underdogs proved to be a massive disappointment for Croatia, the Blazers’ impressive drive to their first-ever berth in a World Cup final has earned them hard-fought status as one of the world’s elite squads. However, Croatia’s heroics at Russia 2018 have done little to boost them on the early 2022 World Cup betting lines, where they lag well behind the favorites as a +5000 wager.
+ #pragma unroll
+ for (int i = 0; i < 4; i++)
+ {
+ uint32_t qa0 = qa & 0x0f;
+ uint32_t qa1 = (qa & 0xf0) >> 4;
+ qa >>= 8;
+ qb |= (qa1 << (i * 4 + 16));
+ qb |= (qa0 << (i * 4));
+ }
+ q[0] = qb;
+}
-A trio of squads coming off disappointing performances at this year’s tournament closely follow Les Bleus on the 2022 World Cup championship odds, with Brazil pegged at +700, ahead of Spain at +750, while 2014 title holders Germany sit at +800.
+__forceinline__ __device__ void dequant_4bit_8
+(
+ const uint32_t q_0,
+ half2 (&dq)[4],
+ int stride
+)
+{
+ const uint32_t c0 = 0x64006400;
+ const half y16_ = __float2half_rn(1.0f / 16.0f);
+ const half2 y16 = __halves2half2(y16_, y16_);
+ const half z1_ = __float2half_rn(-1024.0f - 8.0f);
+ const half z16_ = __float2half_rn(-1024.0f / 16.0f - 8.0f);
+ const half2 z1 = __halves2half2(z1_, z1_);
+ const half2 z16 = __halves2half2(z16_, z16_);
+
+ uint32_t qa = q_0;
+ half2_uint32 q0((qa & 0x000f000f) | c0); // half2(q[ 0], q[ 1]) + 1024
+ half2_uint32 q1((qa & 0x00f000f0) | c0); // half2(q[ 2], q[ 3]) * 16 + 1024
+ qa >>= 8;
+ half2_uint32 q2((qa & 0x000f000f) | c0); // half2(q[ 4], q[ 5]) + 1024
+ half2_uint32 q3((qa & 0x00f000f0) | c0); // half2(q[ 6], q[ 7]) * 16 + 1024
+
+ dq[0] = __hadd2(q0.as_half2, z1);
+ dq[1] = __hfma2(q1.as_half2, y16, z16);
+ dq[2] = __hadd2(q2.as_half2, z1);
+ dq[3] = __hfma2(q3.as_half2, y16, z16);
+}
-The Canarinho traveled to Russia as +400 pre-tournament favorites on the 2018 World Cup odds, and looked poised for a deep knockout stage run after closing out the group stage with a pair of clean-sheet wins. However, Brazil was unable to solve a high-powered Belgium squad in a 2-1 loss that marked their third quarter-final exit in their past four tournament appearances.
+__forceinline__ __device__ void dequant_4bit_8_prep_zero_scale
+(
+ const uint32_t zero,
+ const half scale,
+ half2 (&z1z16)[2],
+ half2 (&y1y16)[2]
+)
+{
+ half_uint16 z1(0xe400 | zero); // half(-1024.0f - zero);
+ half z16 = __hsub(__int2half_rn(-64), __int2half_rn(zero));
-Spain made a second straight early exit at this year’s tournament, falling to Russia on penalties in a Round of 16 match, which marks their only knockout stage appearance since raising the hardware at the 2010 World Cup.
+ half2 scale2 = __half2half2(scale);
-Russia 2018 also proved to be a bitter disappointment for Germany, who closely followed Brazil at +475 on the World Cup futures entering the tournament. However, a shocking 1-0 group stage loss to Mexico as heavy -210 favorites set the tone for Die Mannschaft’s shortest run at a World Cup since 1938.
+ z1z16[0] = __hmul2(scale2, __half2half2(z1.as_half));
+ z1z16[1] = __hmul2(scale2, __half2half2(z16));
-Belgium Trails on 2022 World Cup Betting Lines
+ const half y1 = __float2half_rn(1.0f);
+ const half y16 = __float2half_rn(1.0f / 16.0f);
-Further down the 2022 World Cup odds, Belgium sits at +1100, followed by Argentina at +1200, and Italy at +1800, while England joins the Netherlands at +2000.
+ y1y16[0] = __hmul2(scale2, __half2half2(y1));
+ y1y16[1] = __hmul2(scale2, __half2half2(y16));
+}
-Les Diables Rouges led all squads with 16 goals at Russia 2018, and saw a 25-match unbeaten streak come to an end with a 1-0 loss to France in the semi-finals. Argentina posted just one win in four matches at this year’s tournament, and maintains strong odds despite the uncertain future of superstar Lionel Messi, while Italy and the Netherlands face daunting rebuilding tasks after both European powerhouses failed to qualify for this year’s tournament.
+__forceinline__ __device__ void dequant_4bit_8_prep_zero
+(
+ const uint32_t zero,
+ half2(&z1z16)[2],
+ half2(&y1y16)[2]
+)
+{
+ half_uint16 z1(0xe400 | zero); // half(-1024.0f - zero);
+ half z16 = __hsub(__int2half_rn(-64), __int2half_rn(zero));
-Conversely, England sports a youthful roster, led by top goalscorer Harry Kane, which is likely to make the Three Lions a serious contender at Qatar 2022.
+ z1z16[0] = __half2half2(z1.as_half);
+ z1z16[1] = __half2half2(z16);
-n**(-9/22)
-Simplify ((q/(q*q**11/q*q))/(q**0*q))**(-12) assuming q is positive.
-q**144
-Simplify (s/s**22)/s*s**(-2/11)*s*s assuming s is positive.
-s**(-222/11)
-Simplify (y/(y*(y/(y/(y/(y*y*y**(3/5)))))/y*y))**(-7) assuming y is positive.
-y**(-56/5)
-Simplify o**(-6)*o**13 assuming o is positive.
-o**7
-Simplify q**(-23)*q*q*q**5 assuming q is positive.
-q**(-16)
-Simplify (t/t**(3/10))/(t**(-1)/t)*t*t**(2/3)*t**(-2/17)*t assuming t is positive.
-t**(2677/510)
-Simplify j/j**1*j**(2/15)*(j**(-4)/j)/j*j/(j/(j**(7/5)/j)) assuming j is positive.
-j**(-82/15)
-Simplify d**(-2/13)*d**(-4)*d/(d/(d/d**(-4/5)))*d**(1/5) assuming d is positive.
-d**(-28/13)
-Simplify (((z*z/((z/z**6)/z))/z)/z**(4/3))**(-41) assuming z is positive.
-z**(-697/3)
-Simplify (r**(-1)/r)**(-5/4) assuming r is positive.
-r**(5/2)
-Simplify (j**2/j)**(-33)/(j**(-1/5))**(1/21) assuming j is positive.
-j**(-3464/105)
-Simplify f**(-6)/f*f**(3/2)*(f**1/f)/f**(-5/2) assuming f is positive.
-f**(-3)
-Simplify (v**(2/7)/v)/(v*v**(-2/7)*v)*v**4*(v/(v*v/(v**(-8)*v)))/v assuming v is positive.
-v**(-52/7)
-Simplify ((c/(c*c*c/((c*c**19)/c*c)*c)*c*c)/c)/(((c**(8/9)/c)/c)/c*c) assuming c is positive.
-c**(172/9)
-Simplify (k**(1/3))**(6/17)/(k*k*k/(k*k*k**(2/11)/k*k)*(k*k*k**(3/4))/k) assuming k is positive.
-k**(-1833/748)
-Simplify (q**4*q**(2/11))/((q/q**(1/7))/((q/(q*q**(1/17)*q))/q)) assuming q is positive.
-q**(1657/1309)
-Simplify ((c*c/(c**(3/5)*c))**(-15))**(-15/7) assuming c is positive.
-c**(90/7)
-Simplify (m*m/((m*m**(-3)/m*m)/m))/((m/(m**(1/7)/m)*m)/m)*m*m**9*m/(m/(m*m**(-9))*m)*m assuming m is positive.
-m**(36/7)
-Simplify (v*v/(v/(v*v/(v*v*v**(-2/7)))))**(-13)*(v*v/v**(2/3))**(2/15) assuming v is positive.
-v**(-5209/315)
-Simplify (((o/(o/(o**(1/3)*o*o)))/o*o)**(-1/8))**22 assuming o is positive.
-o**(-77/12)
-Simplify (j*(j**(-5)*j)/j)/j*((j/((j*j**(-1)/j*j*j)/j))/j)/j*((j**(-6)*j*j)/j)/(j*j**(-6)) assuming j is positive.
-j**(-6)
-Simplify w*(w*((w/(w/((w/(w*w/(w*w/w**15)*w*w*w*w*w*w))/w)*w*w))/w*w*w*w)/w)/w*w/w**(1/15) assuming w is positive.
-w**(-301/15)
-Simplify ((i**7/i)/i*i/i**(-5))**40 assuming i is positive.
-i**440
-Simplify (r**0)**33 assuming r is positive.
-1
-Simplify (b**(-17)*b*b**(-10/7))**(5/8) assuming b is positive.
-b**(-305/28)
-Simplify (a**(-2/3)*a)/a**3*(a/(a*a*a**(2/3))*a)/a*a*a/a**(-2/9) assuming a is positive.
-a**(-19/9)
-Simplify (x/x**(-3/2))**48 assuming x is positive.
-x**120
-Simplify ((o*o**(-33/4)*o)/o)/(o**(-48)/o*o) assuming o is positive.
-o**(163/4)
-Simplify (t**(2/9)/(t/(t*(t*t/(t**(-4/5)*t))/t)))**(2/61) assuming t is positive.
-t**(92/2745)
-Simplify x**(1/2)/(x**(-4)/x)*(x/x**(-1))**(-50) assuming x is positive.
-x**(-189/2)
-Simplify l**(-2/31)*l**(-13)/l assuming l is positive.
-l**(-436/31)
-Simplify x**(-2/13)*x**(-20) assuming x is positive.
-x**(-262/13)
-Simplify (h**(28/5))**(-15) assuming h is positive.
-h**(-84)
-Simplify ((w*w*(w*w**(-5/4))/w)/(w*w*w/(w*w/w**(1/13))*w))**(3/17) assuming w is positive.
-w**(-207/884)
-Simplify (x**(2/7))**(1/44) assuming x is positive.
-x**(1/154)
-Simplify a**(-25)*a*a**(3/31) assuming a is positive.
-a**(-741/31)
-Simplify m**(1/3)/m**6*m**3/(m*m*m*m**(-5)/m) assuming m is positive.
-m**(1/3)
-Simplify (((h*h/(h**14*h))/h)/h)/h*h**4 assuming h is positive.
-h**(-12)
-Simplify (x**(-2)*x)**(-1/17)/((((x**(1/3)/x)/x)/x)/x*x*x*x/x**11*x) assuming x is positive.
-x**(547/51)
-Simplify (h**(-2/7)*h/(h/(h*h/(h*h*h**(2/9))*h)))/((h*(h*h/h**6)/h)/h*h**2) assuming h is positive.
-h**(220/63)
-Simplify m**9/m*m/m**(3/20) assuming m is positive.
-m**(177/20)
-Simplify ((q**(-8)*q)/q)**(2/15) assuming q is positive.
-q**(-16/15)
-Simplify (x**(4/9)/x**(2/29))**(2/15) assuming x is positive.
-x**(196/3915)
-Simplify (f**(-1/6))**3/((f/(f**10/f*f))/(f**(4/11)/f)) assuming f is positive.
-f**(173/22)
-Simplify (i*i**(1/2)/i*i)/i*i**(2/11)*i**(1/3)*i**(-6)/i assuming i is positive.
-i**(-395/66)
-Simplify (j/(j*j**(-4))*j**(2/5))/(j**(-4)*j**(1/2)) assuming j is positive.
-j**(79/10)
-Simplify (j/(j*(j/j**(2/13))/j*j))/j**(1/2)*j**(-2/7)*j**1 assuming j is positive.
-j**(-115/182)
-Simplify (k**(-6/5)*k*k*k*k*k*k*k**(2/9)/k*k)**(-3/8) assuming k is positive.
-k**(-113/60)
-Simplify ((h*h**(-3/2)*h)/(h*h/h**(-6)))/(h**(-2/3)/h*h/(h**(-5/4)*h)) assuming h is positive.
-h**(-85/12)
-Simplify y*y*y**(-3/2)*y/y**10*y**(2/7)/y**(-8) assuming y is positive.
-y**(-3/14)
-Simplify (s**(-1/6)/(s/s**(-3/5)))/((s*s**(1/3))/(s/(s**(-3)*s*s))) assuming s is positive.
-s**(-11/10)
-Simplify t/(t/(t*t**(-15/2)))*t/(t**9/t) assuming t is positive.
-t**(-27/2)
-Simplify s*s*s/s**(-8)*s*s/s**(-11)*s assuming s is positive.
-s**25
-Simplify (c*c**(-3))**(7/2)*(c**(2/9))**(1/17) assuming c is positive.
-c**(-1069/153)
-Simplify d**(3/8)*d*d*d**(-2/5) assuming d is positive.
-d**(79/40)
-Simplify (h/h**(-1/11))/h*h*h**(-3/4)*(h**(-2)/h)/(h*h*h**0) assuming h is positive.
-h**(-205/44)
-Simplify (u*u**(8/7)*u)/(u*((u*u**(-3/4))/u)/u*u*u)*(u*u**(-4))/(u/(u*u/(u**(-2/11)/u*u))) assuming u is positive.
-u**(23/308)
-Simplify ((o**(-4/7)*o)/o**0)/((o*o**(-6/11))/(o*o/o**(1/5)*o)) assuming o is positive.
-o**(1068/385)
-Simplify ((c/(c*(c/(c**4*c)*c)/c*c))/(c/c**(-4)))/((c*c**2*c)/(c/c**(-4/5))) assuming c is positive.
-c**(-21/5)
-Simplify a**7*a*((a**(17/4)*a*a)/a*a)/a*a assuming a is positive.
-a**(57/4)
-Simplify ((n*n**5*n*n*n)/n*((n/n**(2/5))/n*n)/n)**(-1/11) assuming n is positive.
-n**(-38/55)
-Simplify (s/(s/s**(3/5)))**3 assuming s is positive.
-s**(9/5)
-Simplify (v*v**(-1/16))/((v**1/v)/v) assuming v is positive.
-v**(31/16)
-Simplify ((d**0)**16)**26 assuming d is positive.
-1
-Simplify i**(-9)*i**(-17) assuming i is positive.
-i**(-26)
-Simplify (((k*k*(k*k**6)/k)/k)/(k**(-3/4)/k))/(k/(k*k**2*k))**(16/3) assuming k is positive.
-k**(99/4)
-Simplify (p**(-4)*p/(p*p**(-4)))**(1/23) assuming p is positive.
-1
-Simplify l**(5/6)/l*l*l**(-7/2) assuming l is positive.
-l**(-8/3)
-Simplify t/(t**15/t)*(t/(t/(t**(2/3)*t)))/t assuming t is positive.
-t**(-37/3)
-Simplify ((b*b**14*b)/b**12)**11 assuming b is positive.
-b**44
-Simplify ((g*g**(2/13))/g)/g**(-6) assuming g is positive.
-g**(80/13)
-Simplify (v/v**(10/7))**(2/87) assuming v is positive.
-v**(-2/203)
-Simplify (t/(t*t**(-4/5)))**(-50) assuming t is positive.
-t**(-40)
-Simplify g**(-2/7)*g**(-2)*(g*g/(g/g**(-1)*g))**(-2/101) assuming g is positive.
-g**(-1602/707)
-Simplify ((v*v**(-1/4))/(v/(v*v/(v**(-1/2)/v)*v)))/(v**(2/7)/v)**(5/7) assuming v is positive.
-v**(933/196)
-Simplify (b**(-3/5)*((b/(b/(b*b**(-1))))/b*b)/b)/(b**(1/3)*b**10/b) assuming b is positive.
-b**(-164/15)
-Simplify (h**(1/14)*h**(-4)*h)**(1/39) assuming h is positive.
-h**(-41/546)
-Simplify (y**(-1))**(-1/18)*(y*y/(y/(y**(-2/5)*y))*y)**(-45) assuming y is positive.
-y**(-2105/18)
-Simplify (z**(-2/11)/z*z)**(-3/23) assuming z is positive.
-z**(6/253)
-Simplify (k*k**(-1))**14*k**(-1)*k**5/k assuming k is positive.
-k**3
-Simplify ((m*m**(-2/7)*m)/m**(-4))/(m*m*m**(-4)/m*m*m*m/m**5*m) assuming m is positive.
-m**(68/7)
-Simplify ((j*j**(-2))/j)**(-2/61)/((j*j/j**1)/j*j)**(-35) assuming j is positive.
-j**(2139/61)
-Simplify (u**(-1/12)*u)**17 assuming u is positive.
-u**(187/12)
-Simplify ((z**(-2/17)*z*z)**(7/3))**(2/5) assuming z is positive.
-z**(448/255)
-Simplify i**(-1/15)*i**10*i assuming i is positive.
-i**(164/15)
-Simplify (w**3/((w/w**(5/3))/w*w))**(-2/109) assuming w is positive.
-w**(-22/327)
-Simplify z**(2/17)/z*z**(7/4) assuming z is positive.
-z**(59/68)
-Simplify ((s*s/(s/(s**(-6/5)/s)*s))/s)/s**(4/5) assuming s is positive.
-s**(-4)
-Simplify i**24*i*i/i**(-6)*i assuming i is positive.
-i**33
-Simplify ((v*v*v/(v*(v*v*v**(-1/9)*v)/v))/(v/v**6*v*v))/(v**(-1/5)/v**3) assuming v is positive.
-v**(284/45)
-Simplify (n/(n*n/(n/(((n*n**(-4))/n)/n)*n))*n**(-2/9))/(n*n*n**4*n*n**(-1/3)) assuming n is positive.
-n**(-8/9)
-Simplify ((l/l**(-1/11))/l)/l**(-24) assuming l is positive.
-l**(265/11)
-Simplify l**3*(l*l**(-8)*l)/l assuming l is positive.
-l**(-4)
-Simplify ((k/k**(-3/2))/k**(12/7))**(2/29) assuming k is positive.
-k**(11/203)
-Simplify (((t*t*t*t*t*t/t**(-1/12))/t)/(t*t**(-2/3)))**28 assuming t is positive.
-t**133
-Simplify (g/(g**(2/23)/g))/(g*g*((g*g*g**(11/4))/g*g)/g*g) assuming g is positive.
-g**(-445/92)
-Simplify (o**(-2)/(o/(o/((o/(o**(-13)*o*o))/o*o))))**(4/7) assuming o is positive.
-o**(-8)
-Simplify a**(5/7)*a/a**(8/9) assuming
-5 Surprisingly Easy Tricks to Make Running a Habit
+ const half y1 = __float2half_rn(1.0f);
+ const half y16 = __float2half_rn(1.0f / 16.0f);
-You were really excited…
+ y1y16[0] = __half2half2(y1);
+ y1y16[1] = __half2half2(y16);
+}
-You had signed up for a 6k run in your neighbourhood. You had also joined the local running club.
-You were really motivated, weren’t you?
-Your willpower was on a sprint and you were geared up to bolt towards the finishing line.
+__forceinline__ __device__ void dequant_4bit_8_gptq
+(
+ const uint32_t q_0,
+ half2 (&dq)[4],
+ half2 (&z1z16)[2],
+ half2 (&y1y16)[2],
+ int stride,
+ bool scaled
+)
+{
+ const uint32_t c0 = 0x64006400;
-But then…
+ uint32_t qa = q_0;
+ half2_uint32 q0((qa & 0x000f000f) | c0); // half2( q[0] + 1024, q[1] + 1024 )
+ half2_uint32 q1((qa & 0x00f000f0) | c0); // half2( q[2] * 16 + 1024, q[3] * 16 + 1024 )
+ qa >>= 8;
+ half2_uint32 q2((qa & 0x000f000f) | c0); // half2( q[4] + 1024, q[5] + 1024 )
+ half2_uint32 q3((qa & 0x00f000f0) | c0); // half2( q[6] * 16 + 1024, q[7] * 16 + 1024 )
-You went for a vacation or a work trip for a week.
-What happened when you got back?
+ if (scaled)
+ {
+ dq[0] = __hfma2(q0.as_half2, y1y16[0], z1z16[0]); // half2( q[0] * s - z * s, q[1] * s - z * s)
+ dq[1] = __hfma2(q1.as_half2, y1y16[1], z1z16[1]); // half2( q[2] * s - z * s, q[3] * s - z * s)
+ dq[2] = __hfma2(q2.as_half2, y1y16[0], z1z16[0]);
+ dq[3] = __hfma2(q3.as_half2, y1y16[1], z1z16[1]);
+ }
+ else
+ {
+ dq[0] = __hadd2(q0.as_half2, z1z16[0]); // half2( q[0] - z, q[1] - z )
+ dq[1] = __hfma2(q1.as_half2, y1y16[1], z1z16[1]); // half2( q[2] - z, q[3] - z )
+ dq[2] = __hadd2(q2.as_half2, z1z16[0]); // half2( q[4] - z, q[5] - z )
+ dq[3] = __hfma2(q3.as_half2, y1y16[1], z1z16[1]); // half2( q[6] - z, q[7] - z )
+ }
+}
-Do you still have that initial momentum?
-Do you feel like giving up, because starting over is such a pain?
-Is it tough to find time?
+#else
-Sticking to a new habit isn’t easy.
+__forceinline__ __device__ void shuffle_4bit_8
+(
+ uint32_t* q,
+ int stride
+)
+{
+}
-I know! I had tried to make running a habit for ages and failed miserably.
+__forceinline__ __device__ void dequant_4bit_8
+(
+ const uint32_t q_0,
+ half2 (&dq)[4],
+ int stride
+)
+{
+ half dqh[8];
+ for (int i = 0; i < 8; i++) dqh[i] = dq_ns(exb(q_0, i * 4, 0x0f), 8);
-Eventually I got tired of failing.
-That’s when I began to read about the science of habit formation. I tried to find smart and simple ways to make habits stick.
+ for (int i = 0; i < 4; i++) dq[i] = __halves2half2(dqh[i * 2], dqh[i * 2 + 1]);
+}
-Today I can lace up my shoes and go for a regular jog every 4-5 days a week and with ease.
+__forceinline__ __device__ void dequant_4bit_8_prep_zero_scale
+(
+ const uint32_t zero,
+ const half scale,
+ half2 (&z1)[2],
+ half2 (&y1)[2]
+)
+{
+ half z = __int2half_rn(-((int)zero));
+ z = __hmul(z, scale);
+ z1[0] = __half2half2(z);
+ y1[0] = __half2half2(scale);
+}
-Check out these 5 surprisingly easy tricks that have helped me make running a habit:
+__forceinline__ __device__ void dequant_4bit_8_prep_zero
+(
+ const uint32_t zero,
+ half2(&z1)[2],
+ half2(&y1)[2]
+)
+{
+ half z = __int2half_rn(-((int)zero));
+ z1[0] = __half2half2(z);
+}
-1. Create a trigger
+__forceinline__ __device__ void dequant_4bit_8_gptq
+(
+ const uint32_t q_0,
+ half2 (&dq)[4],
+ half2 (&z1)[2],
+ half2 (&y1)[2],
+ int stride,
+ bool scaled
+)
+{
+ half2 dqh2[8];
-According to Charles Duhigg, the bestselling author of “The Power of Habit”, Triggers act as conscious or subconscious reminders to perform a behaviour.
+ uint32_t qa = q_0;
+ for (int i = 0; i < 4; i++)
+ {
+ half d0 = __int2half_rn(qa & 0x0f); qa >>= 4;
+ half d1 = __int2half_rn(qa & 0x0f); qa >>= 4;
+ dqh2[i] = __halves2half2(d0, d1);
+ }
-Triggers could be visual reminders. Try keeping your running gear and shoes next to your bed so you see them first thing in the morning.
+ if (scaled)
+ {
+ dq[0] = __hfma2(dqh2[0], y1[0], z1[0]);
+ dq[1] = __hfma2(dqh2[1], y1[0], z1[0]);
+ dq[2] = __hfma2(dqh2[2], y1[0], z1[0]);
+ dq[3] = __hfma2(dqh2[3], y1[0], z1[0]);
+ }
+ else
+ {
+ dq[0] = __hadd2(dqh2[0], z1[0]);
+ dq[1] = __hadd2(dqh2[1], z1[0]);
+ dq[2] = __hadd2(dqh2[2], z1[0]);
+ dq[3] = __hadd2(dqh2[3], z1[0]);
+ }
+}
-Triggers can also be action based. I run in the evenings and my trigger is “right after I drink my evening coffee, I will go running”.
+#endif
-2. Be specific
+#endif
-During the first 4-6 weeks of picking up running as a habit specify a time of day (or night), the exact trail you will go for the run, duration of the run and at what time will you leave for the run.
+import gc
+import torch
+from torch import nn
+import torch.nn.functional as F
+import math
+from exllamav2.ext import exllamav2_ext as ext_c, none_tensor
+from exllamav2.util import list_live_tensors
-The more specific you can make the action, the easier it is to implement it everyday.
-You can use this statement: “I will go running every Monday, Tuesday, Thursday and Friday at my neighbourhood park in the evening at XX pm (write the time here) for 30 minutes”.
+class AdaptiveQuantizer:
-3. Start small
+ norm: float = 3.5
+ max_p: float = 1.0
+ min_p: float = 0.75
+ p_grid: int = 48
-Habit coach Rob Norback strongly advocates the half-and-half rule. If you want to run for 20 minutes every day, cut it into half (10 minutes) then half it again (5 minutes). That’s where you should start.
+ bits: int
+ scale_bits: int
+ scale_range: float = 1.0
-Doesn’t that sound a lot more achievable?
-Even if you can run for 10-15 minutes, stick to a 5 minute routine until it becomes second nature. Only once it’s become a habit should you start running for longer periods.
+ scale: torch.tensor
+ qscale: torch.tensor
+ qscale_max: float
-How does this help?
+ maxq: float
+ scale_maxq: float
+ qzero: float
-You complete your goal in 5 minutes and that brings a sense of accomplishment which is essential to building habits.
+ def __init__(self,
+ bits: int = 4,
+ scale_bits: int = 4):
-You overcome any procrastination or hurdles (you woke up late, have to rush to office, send the kids to school) that you may face, since you have to invest only 5 minutes.
+ self.bits = bits
+ self.scale_bits = scale_bits
+ self.maxq = 2 ** bits - 1
+ self.qzero = (self.maxq + 1) / 2
+ self.scale_maxq = 2 ** scale_bits - 1
-4. Forgive yourself
+ self.scale_maxq = (2 ** self.scale_bits) - 1
-If you miss a day (which you inevitably will) do NOT berate yourself.
-Missing a day is no big deal. But assuming defeat because you missed 1 day or 2 days in a row (or a whole week while vacationing), is a huge mistake.
+ def find_params(self, x):
-Negative thinking will make you give up. If you think you have failed or you are lazy or you are not good at running, it will stop you from taking further action.
+ xmax, _ = torch.max(torch.abs(x), dim = 0)
+ xmax += 1e-12
-5. Get a good night’s sleep
+ base_scale = xmax / (self.maxq / 2)
+ qscale_max_t = torch.max(base_scale) * self.scale_range
-Sleep matters! If you are not getting at least 6.5 hours of shut eye every night you will be tired, with little energy to focus on habit changes.
+ scale_tp = base_scale / qscale_max_t
+ scale_tp = torch.sqrt(scale_tp)
+ scale_tp *= (self.scale_maxq + 1)
+ qscale_t = torch.clamp(torch.round(scale_tp), 1, self.scale_maxq + 1)
+ qscale_tw = qscale_t / (self.scale_maxq + 1)
+ qscale_tw = qscale_tw ** 2
+ qscale_tw *= qscale_max_t
-You might make it to the park when your enthusiasm and motivation for running is high, but the moment things get even slightly difficult, you’ll skip the habit because as a sleep-deprived person you wouldn’t have the willpower to push yourself through a little discomfort.
+ q = torch.zeros((self.p_grid + 1, 128), dtype = torch.float, device = x.device)
+ ext_c.quantize_err(x, q, qscale_tw, self.qzero, self.maxq, self.norm, self.min_p, self.max_p, self.p_grid)
-Why 6.5 and not 7 hours?
-Because, Tony Schwartz, Energy Coach, recommends that half an hour of exercise can actually compensate for half an hour of sleep and give you more energy in the bargain!
+ q = torch.sum(q, dim = 1)
+ best_pi = torch.argmin(q)
+ best_pif = best_pi / self.p_grid
+ best_p = self.max_p * best_pif + self.min_p * (1 - best_pif)
-What habit do you want to pick up?
+ # best_p = 1.0
-Work out at home, follow a diet, wake up early, learn music, maybe a language, study for a certification?
+ self.qscale = qscale_t.to(torch.short)
+ self.scale = qscale_tw * best_p
+ self.qscale_max = qscale_max_t * best_p
-These principles work for any kind of habit formation. Try it!
-Want to know about that one core ingredient for forming any habit? Sign up for our Blog.
-Thursday, May 14, 2009
+class AdaptiveGPTQ:
-Again between two guys a hell of a lot smarter than you. Me and James.
+ percdamp: float = 0.07
-Just a reminder Channelup is in Italics, James in regular font.
+ layer: nn.Linear
+ device: torch.device
-Yo buddy
+ group_size: int
+ bits: list
+ bits_groups: list
+ scale_bits: int
+ hot_bits: int
-Last night's lost was nothing if not interesting. I liked it (thought it could have been an hour and a half) and thought it did a pretty good job setting up next season. Writing about it was insanely hard as I had a lot of trouble gathering my thoughts and putting them in a coherent format. I obviously wanted to avoid just straight summarizing, but there was so much going on. Anyway I thought I would add a couple of more thoughts that didn't make it into my post.
+ columns: int
+ rows: int
+ hessian: torch.tensor
+ total_groups: int
-- I kind of mention this but the good/evil thing is really going to be the main focus of the last season I think. Ben and Mystery Island guy leading the charge to keep the island secret from everyone with others (Richard Alpert maybe? Shadow of the statue group?) fighting for their own end games. That storyline has the potential to be awesome and maddening at the same time.
+ perm: torch.tensor = None
+ invperm: torch.tensor = None
-- The bomb explosion will probably make it so that the Oceanic crew (plus Miles and Juliette) can somehow jump back to the present and back into the fray. One thing I liked about this season with them alternating between different points in time, is that there wasnt too much overlap and confusion with the characters. Basically keeping it so that everyone easnt always running into each other worked for the production of the show. Putting them all back in to the same time, with Alpert and company's increasing role, plus this new faction, could be tough.
+ g_idx: torch.tensor = None
+ scale: torch.tensor = None
+ qscale: torch.tensor = None
+ qscale_max: torch.tensor = None
+ qweight: torch.tensor = None
+ qgroups: torch.tensor = None
+
+ quant: torch.tensor = None
+ weights: torch.tensor = None
+ hessian: torch.tensor = None
+ hessian_inv: torch.tensor = None
+ num_samples: int = 0
+ num_batches: int = 0
+
+
+ def __init__(self,
+ layer: nn.Linear):
+
+ self.layer = layer
+ self.device = layer.weight.device
+
+ self.rows = self.layer.weight.data.shape[1]
+ self.columns = self.layer.weight.data.shape[0]
+
+ self.weights = self.layer.weight.data.T.clone().float().contiguous()
+ self.hessian = None
+ self.num_samples = 0
+ self.num_batches = 0
+
+
+ def drop_buffers(self):
+
+ self.perm = None
+ self.invperm = None
+ self.g_idx = None
+ self.scale = None
+ self.qscale = None
+ self.qscale_max = None
+ self.qweight = None
+ self.qgroups = None
+ self.quant = None
+ self.weights = None
+ self.hessian = None
+ self.hessian_inv = None
-Any other thoughts? I think I have now written 10,000 words on Lost.
+ gc.collect()
+ torch.cuda.empty_cache()
-Interesting idea about the bomb sending the main characters forward in time. Supporting that idea is the fact that they used the exact same screen effect when we are meant to believe the bomb goes off as when we have traveled in time previously.
-So this foil to Jacob doesn't actually resurrect Locke - but turns himself into an image of Locke? So are we meant to believe this guy also turned himself into a vision of Jack's Dad, Walt, etc? Even though it's bizarre, I suppose it's at least a consistent explanation.
+ def configure(self,
+ group_size: dict,
+ bits = None,
+ bits_prop = None,
+ scale_bits: int = 4
+ ):
-I am not sure if I like the idea of the island being this place where two gods are battling for supremacy. I also don't get why Jacob would just let Ben wave that knife around and then kill him(if he is indeed dead) considering he earlier exercised the power to bring a human being back to life when Locke was thrown from the window. And to be honest, I also thought the "Jacob was actually there at all of these huge moments in all of the Losties lives" got extremely old after the first couple. The first one I was like WHOA!!! and then after that it sort of felt like cheap thrills. Jacob sitting on a bench...Locke falls from the window! Can you believe it?! Jacob was there when Locke was thrown out of the window, too! So I guess what I am saying is, I agree that the episode stands up a lot better as an hour and a half instead of 2 hours. This is sort of a shame considering I felt like some of the other huge plot points were sort of rushed.
+ self.group_size = group_size
+ self.scale_bits = scale_bits
+ self.bits = bits
-We need to see Jacob at Sun and Jin's wedding, but all we get for the most pivotal turning point is the episode is Juliet saying "I changed my mind. I saw the way you looked at her," and a weak explanation? Juliet similarly instantly changes her mind in the sub to get them back to the island...I guess she didn't see any suspicious looks by Sawyer in any of the other dozens of times he and Kate interracted since she got back? I just thought this was a very hurried and sloppy way to make sure everyone got back on the island while also letting Jack's plan carry on. It felt like forced drama, which LOST has done a good job avoiding this season. Easier would have just been to not place Sawyer, Juliet, and Kate on the sub...avoid some empty action scenes of their escape, Sawyer and Jack's fight, the "Why'd you stop," "That's why dude," Hurley and Jack moment, and so on.
+ assert isinstance(bits, list)
+ assert isinstance(bits_prop, list)
+ assert sum(bits_prop) == 1
-Why couldn't Juliet have given her "i saw the way you looked at her" speech when Sawyer first suggests going on the sub in the first place? We are still in the same place, but we have room for further development elsewhere. Would it have been so bad if we saw MIles saying to his father, "Now I understand why you did it," and then playing a bigger role in all of this instead of just having this awesome character making snarky comments in the background from time to time? Perhaps another interraction between Jacob and Evil Jacob at some other point in time(like when Oceanic 815 crashes). My overall point is, as I am sure you can tell by now - a few storylines left me wanting more and a few left me wanting decidedly less. I think either trimming it down, or re-organizing it while dropping the fluff would have been a far more impactful finale. I do agree though, that the events that happened set us up well for next season.
+ groups = 0
+ remaining_rows = self.rows
+ self.bits_groups = []
+ for b, p in zip(self.bits, bits_prop):
+ assert p > 0
+ gsz = self.group_size[b]
+ g = math.ceil(min(self.rows * p, remaining_rows) / gsz)
+ groups += g
+ remaining_rows -= g * gsz
+ self.bits_groups.append(g)
-Totally agree about the Jacob appearances. I thought some were cool (Sawyer, Sayid, Locke) and some were stupid (Jin and Sun, Jack). Also they kind of throw you off with Juliet's parents getting divorced and Jacob not showing up. When he doesnt show it kind of makes the whole thing some weird set up for why she leaves Sawyer. To be honest, the whole Sawyer, Kate Juilet thing has annoyed me for a while and I find it very hollow. What I did enjoy about Sawyer though was the genuine anguish (not for losing Juliet), but for losing the life he had in the Dharma Initiative. He was kind of saying, "I finally made a normal life for myself and you (Jack) came along and f-ed it up like you always do." That is where I felt most pity for him as a character.
+ assert remaining_rows <= 0
-Also the scene where they are about to explode the bomb was beyond ridiculous considering an alarm is going off, the Dharma initiative is on to them, Sayid is dying and every sits around to talk about their feelings for ten minutes. No possible way.
+ self.total_groups = groups
-Agree totally about the sub and its uselessness in the overall plot. Just a filler. I doubt Jacob is actually dead and we need to consider that his body is most likely just some kind of vessel to a more supreme being. I don't know if I love these God implications because they complicate things almost more than time travel does. People with God-like powers (Sylar) are just as impossible as those who try and change the future or past.
-The true test of character is not how much we know how to do, but how we behave when we don't know what to do.
+ # if isinstance(bits, list):
+ #
+ # self.bits = bits
+ # g128 = (self.rows + 128 - 1) // 128
+ # self.bits_groups = [max(round(g128 * p), 1) * 128 // self.group_size for p in bits_prop]
+ # e = sum(self.bits_groups) - self.total_groups
+ # self.bits_groups[-1] -= e
+ #
+ # else:
+ #
+ # self.bits = [bits]
+ # self.bits_groups = [self.total_groups]
-Friday, August 28, 2009
-Free from blackness
+ # def num_bits(self, subtract_columns = 0):
+ #
+ # gi = self.g_idx.numel() * 32
+ # qs = self.qscale.numel() * self.scale_bits
+ # qss = self.qscale_max.numel() * 16
+ #
+ # w = 0
+ # tr = self.rows
+ # for g, b in zip(self.bits_groups, self.bits):
+ #
+ # c = self.columns - subtract_columns
+ # r = self.group_size * g
+ # if r > tr: r = tr
+ # tr -= r
+ # w += r * c * b
+ #
+ # return w + gi + qs + qss
-Independence day celebration is just around the corner. It’s been 52 years our beloved country celebrated independence and our country had achieve a lot since then. This time around since the independence fall on Ramadhan time so I bet there will be not many concerts or socialize party organized in KL or anywhere else but then, it’s just my predictions, other races might as well did it.Talking about independence, what has we, as the children of the post independence know about the value of freedom? Freedom means free from any colonization if that what it means from the past but nowadays out culture are so much been conquered by other races, culture. Our country fills with “PATI”. Anywhere we walk we can see many faces and sometimes I wonder, am I the foreigner here?Yeah2 I know the globalization means that you have to accept the windows of the world into your world but then if the newcomers come and made a hell out my country so what it is going to be? It’s ok for them to work here and made a decent earning with living peacefully with the locals but the main problem is the one that cause the social problem. What we saw in newspaper and news are just the tips of the reports and I’m pretty sure there are many more cases of robbery, thief, snatch, rape, murder involving these ‘type’ of people. Mastika (August Edition) had some stories of how the Negro affecting our life here in Malaysia. Sometimes I wonder, how can they come here? With so many of them? And the usual stories that link with Negro are theft, “pukau”, money counterfeit, rape (which was at first called love).i like to gather some info from all of you about the last one. We see and find this thing in KL right? We can see a nice lovely Malay girls walking along MidValley, hold hand with some Black tall guy. I still wonder why on earth that these ladies picked and fall in love with the Negro? I means they are Christian (some might be Muslim), Black( if you want to choose black, it’s better to choose the Indian) and not handsome ( Malays are so hotter than them)? Why and How? And if their love story end with happy ending good for them but the problem is the ending just like in the 999 (tv3 program).The Negro slept with the girl and then he dumped her and to make matter worse, the girl pregnant and the child with the DNA of Negro was born. So who’s to blame here? The Negro of course, but the girls too.What makes Negro or (in the whole) the foreigners better than the locals? I can stand Malays girls couple with Indians or Chinese as long as same Religion (I mean Islam of course), but I can’t stand if Malays or Chinese or Indians couple with foreigner. It’s like the man from our country had extinct that force them to find foreigner. The same usual lame reasons for these girls to find Negro or “Mat Salleh” are romantic, caring, loving and obviously richer. I would say it is bullshit. The story had been always having the same ending.This is also one type of colonization and proofs that we, Malaysians still not fully achieve Independence. We always value the outside goods higher than our own local goods without ever considering the quality first.The value of Independence means nothing if just some people say aloud “Merdeka” each year and put on the flag on the car, house or office. The values of independence should come within the heart of every Malaysian and together we care and cherish this gift for the good of the future.Happy Independence Day!p/s – My car might not have the flag of Malaysian but in my heart, the love of this country, none can compared with. Well, I shall put on the flag afterwards. Hope all of you did the same things. The first is Islam and the second is Malaysia and I do mean “Malay-sia”.
-.versionSelectItem {
- display: grid;
- grid-template-columns: 70px auto 130px;
- .changeLog {
- overflow: hidden;
- text-overflow: ellipsis;
- white-space: nowrap;
- padding-right: 10px;
- }
+ def add_batch(self, inputs):
+
+ with torch.inference_mode():
+
+ if self.hessian is None:
+ self.hessian = torch.zeros((self.rows, self.rows), device=self.device, dtype=torch.float)
+
+ self.num_batches += 1
+ num_samples = len(inputs)
+ inputs = torch.cat(inputs, dim = 0)
+ inputs = inputs.view((-1, inputs.shape[-1])).float().T.to("cuda:0")
+ inputs *= math.sqrt(2 / num_samples)
+ self.hessian += inputs.matmul(inputs.T)
+
+
+ def prepare(self):
+
+ with torch.inference_mode():
+
+ self.hessian /= self.num_batches
+
+ diagonal = torch.diag(self.hessian)
+
+ # Zero weights that have no impact. Disabling this since it feels a little drastic based on just the calibration
+ # data. It likely never triggers, anyway.
+
+ # dead = diagonal == 0.0
+ # self.hessian[dead, dead] = 1
+ # self.weights[dead, :] = 0
+
+ # Activation order
+
+ self.perm = torch.argsort(diagonal, descending = True)
+ self.weights = self.weights[self.perm, :]
+ hessian = self.hessian[self.perm][:, self.perm]
+ self.hessian = None
+
+ # In case numerical errors have caused some asymmetry in H, assume it's close to symmetrical and force it.
+ # (Doesn't seem to be needed)
+
+ # torch.cuda.empty_cache()
+ # hessian = (hessian + hessian.T) * 0.5
+ # torch.cuda.empty_cache()
+
+ # Damping
+
+ diagonal = torch.diag(hessian)
+ damp = torch.clamp(self.percdamp * torch.mean(diagonal), min = 1e-5)
+
+ # Inverse of H
+
+ attempts = 0
+ while True:
+
+ try:
+
+ d = torch.arange(self.rows, device = self.device)
+ hessian[d, d] += damp
+
+ # Dump condition number and smallest eigenvalue (should be positive)
+
+ # fro_norm_hessian = torch.norm(hessian, p = 'fro')
+ # fro_norm_inv = torch.norm(torch.linalg.inv(hessian), p = 'fro')
+ # cond_number = fro_norm_hessian * fro_norm_inv
+ # print(cond_number)
+
+ # eigenvalues = torch.linalg.eigvalsh(hessian)
+ # is_pd = torch.all(eigenvalues > 0)
+ # print(is_pd)
+ # print(torch.min(eigenvalues))
+
+ hessian_inv = torch.linalg.cholesky(hessian)
+ hessian_inv = torch.cholesky_inverse(hessian_inv)
+
+ # The Cholesky inverse will sometimes fail to compute due to accumulated rounding errors when H
+ # is very large (e.g. 70B MLP down proj) and a lot of calibration data is used (e.g. 100 rows of
+ # 4096 tokens). This won't always throw an exception and sometimes just results in a NaN tensor.
+
+ if torch.any(torch.isnan(hessian_inv)): raise RuntimeError
+
+ # Test inversion
+
+ # test = hessian_inv @ hessian
+ # test.sub_(torch.eye(test.size(0), device = test.device, dtype = test.dtype))
+ # test **= 2
+ # test = test.mean()
+ # print(test)
+
+ hessian_inv = torch.linalg.cholesky(hessian_inv, upper = True)
+ hessian_inv = hessian_inv.contiguous()
+
+ break
+
+ except RuntimeError:
+
+ # If inverting failed, assume there were non-positive eigenvalues, so apply more damping to shift
+ # the eigenvalues in a positive direction.
+
+ print(" !! Warning: Applied additional damping")
+
+ attempts += 1
+ if attempts == 10:
+ raise ValueError("Hessian is not invertible")
+
+ self.hessian_inv = hessian_inv
+ self.hessian = None
+
+ def reuse_h(self, other):
+
+ with torch.inference_mode():
+
+ self.hessian_inv = other.hessian_inv
+ self.hessian = None
+ self.perm = other.perm
+ self.weights = self.weights[self.perm, :]
+
+
+ def quantize(self, keep_qweight = False, apply = False, drop = False):
+
+ with torch.inference_mode():
+
+ if apply:
+ weights = self.weights
+ self.layer.weight.data = torch.zeros((1, 1), dtype = torch.float32, device = weights.device)
+ else:
+ weights = self.weights.clone()
+
+ self.quant = torch.zeros_like(self.weights)
+
+ if keep_qweight:
+ self.qweight = torch.zeros_like(weights, dtype = torch.short)
+
+ # Quantize groups
+
+ scale = []
+ qscale = []
+ qscale_max = []
+ qgroups = []
+
+ error = weights.clone()
+ group_idx = 0
+ group_idx_list = []
+
+ b = 0
+ for bits_idx, bits in enumerate(self.bits):
+ quantizer = AdaptiveQuantizer(bits = bits, scale_bits = self.scale_bits)
+
+ for group in range(self.bits_groups[bits_idx]):
+ a = b
+ b = min(a + self.group_size[bits], self.rows)
+
+ qgroups.append(bits)
+ qgroups.append(0)
+
+ quantizer.find_params(weights[a : b, :])
+ scale.append(quantizer.scale)
+ qscale.append(quantizer.qscale)
+ qscale_max.append(quantizer.qscale_max)
+
+ ext_c.quantize_range(self.quant,
+ quantizer.scale,
+ self.qweight if keep_qweight else none_tensor,
+ quantizer.qzero,
+ quantizer.maxq,
+ self.hessian_inv,
+ weights,
+ error,
+ a,
+ b)
+
+ group_idx_list += [group_idx] * (b - a)
+ group_idx += 1
+
+
+ # Create g_idx to store inverse activation order
+
+ self.g_idx = torch.tensor(group_idx_list, dtype = torch.int32, device = self.device)
+
+ self.invperm = torch.argsort(self.perm)
+ self.g_idx = self.g_idx[self.invperm]
+
+ # Store scales
+
+ self.scale = torch.stack(scale, dim = 0)
+ self.qscale = torch.stack(qscale, dim = 0)
+ self.qscale_max = torch.tensor(qscale_max, dtype = torch.float16, device = self.device)
+ self.qgroups = torch.tensor(qgroups, dtype = torch.short, device = self.device)
+
+ # Apply
+
+ if apply:
+ if drop:
+ weights = None
+ error = None
+ scale = None
+ qscale = None
+ qscale_max = None
+ qgroups = None
+ group_idx_list = None
+ gc.collect()
+ torch.cuda.empty_cache()
+ self.apply_quant()
+
+
+ def quant_error(self):
+
+ with torch.inference_mode():
+
+ q = self.quant[self.invperm, :]
+ diff = torch.abs(q - self.layer.weight.data.T)
+ mat_error_1 = (diff > 0.01).sum().item() / diff.numel()
+ mat_error_5 = (diff > 0.05).sum().item() / diff.numel()
+ mat_error_10 = (diff > 0.10).sum().item() / diff.numel()
+ return mat_error_1, mat_error_5, mat_error_10
+
+
+ def apply_quant(self):
+
+ qc = self.quant.cpu()
+ invperm = self.invperm.cpu()
+ q = qc[invperm, :].T
+ q = q.reshape(self.quant.T.shape)
+ q = q.to(self.quant.device)
+ self.layer.weight.data = q
+
+
+ def apply_temp(self):
+
+ q = self.quant[self.invperm, :].T
+ temp_layer = nn.Linear(self.layer.in_features, self.layer.out_features, False, device = "meta", dtype = torch.float16)
+ temp_layer.weight = nn.Parameter(q.reshape(self.layer.weight.shape).type_as(self.layer.weight.data))
+ return temp_layer
+
+
+ def pack(self, key, qparams):
+
+ assert qparams.scale_bits in [4]
+ # assert self.columns % 32 == 0
+
+ output = {}
+ output[key + ".q_invperm"] = self.invperm.to(torch.int)
+ output[key + ".q_scale_max"] = self.qscale_max
+ output[key + ".q_groups"] = self.qgroups
+
+ columns = self.columns
+ rem_rows = self.rows
+ padding = -columns % 32
+
+ if padding != 0:
+ print(f" !! Note: Padding quantized tensor {key}")
+ qst = F.pad(self.qscale, (0, padding)).contiguous()
+ qwt = F.pad(self.qweight, (0, padding)).contiguous()
+ else:
+ qst = self.qscale
+ qwt = self.qweight
+
+ qst_packed = torch.zeros((qst.shape[0], qst.shape[1] * qparams.scale_bits // 32), dtype = torch.int32, device = self.device)
+ if qparams.scale_bits == 4: ext_c.pack_rows_4(qst, qst_packed)
+ # if qparams.scale_bits == 6: ext_c.pack_rows_6(qst, qst_packed) # TODO:
+ output[key + ".q_scale"] = qst_packed
+
+ qwt_packed = []
+
+ i = 0
+ row = 0
+ out_row = 0
+ while i < self.qscale.shape[0]:
+
+ bits = self.qgroups[i * 2].item()
+ self.qgroups[i * 2 + 1] = out_row
+ i += 1
+
+ rows = min(self.group_size[bits], rem_rows)
+ wpqr = 32 / bits
+ qrows = rows / wpqr
+ assert i == self.qgroups.shape[-1] or qrows == int(qrows)
+ qrows = math.ceil(qrows)
+
+ g_qwt = qwt[row:row+rows, :].contiguous()
+ g_qwt_packed = torch.zeros((qrows, columns + padding), dtype = torch.int32, device = self.device)
+
+ if padding > 0: g_qwt[:, -padding:] = 2 ** (bits - 1)
+
+ ext_c.pack_columns(g_qwt, g_qwt_packed, bits)
+ qwt_packed.append(g_qwt_packed)
+
+ # print(row, rows, bits)
+
+ row += rows
+ out_row += qrows
+ rem_rows -= rows
+
+
+ qwt_packed = torch.cat(qwt_packed, dim = 0)
+ output[key + ".q_weight"] = qwt_packed
+
+ return output
+
+
+This page shows examples of messages formatted using JSON (JavaScript Object Notation).
+
+{
+ "glossary": {
+ "title": "example glossary",
+ "GlossDiv": {
+ "title": "S",
+ "GlossList": {
+ "GlossEntry": {
+ "ID": "SGML",
+ "SortAs": "SGML",
+ "GlossTerm": "Standard Generalized Markup Language",
+ "Acronym": "SGML",
+ "Abbrev": "ISO 8879:1986",
+ "GlossDef": {
+ "para": "A meta-markup language, used to create markup languages such as DocBook.",
+ "GlossSeeAlso": ["GML", "XML"]
+ },
+ "GlossSee": "markup"
+ }
+ }
+ }
+ }
+}
+
+The same text expressed as XML:
+
+
+ example glossary
+ S
+
+
+ Standard Generalized Markup Language
+ SGML
+ ISO 8879:1986
+
+ A meta-markup language, used to create markup
+languages such as DocBook.
+
+
+
+
+
+
+
+
+
+{"menu": {
+ "id": "file",
+ "value": "File",
+ "popup": {
+ "menuitem": [
+ {"value": "New", "onclick": "CreateNewDoc()"},
+ {"value": "Open", "onclick": "OpenDoc()"},
+ {"value": "Close", "onclick": "CloseDoc()"}
+ ]
+ }
+}}
+
+The same text expressed as XML:
+
+
+
+{"widget": {
+ "debug": "on",
+ "window": {
+ "title": "Sample Konfabulator Widget",
+ "name": "main_window",
+ "width": 500,
+ "height": 500
+ },
+ "image": {
+ "src": "Images/Sun.png",
+ "name": "sun1",
+ "hOffset": 250,
+ "vOffset": 250,
+ "alignment": "center"
+ },
+ "text": {
+ "data": "Click Here",
+ "size": 36,
+ "style": "bold",
+ "name": "text1",
+ "hOffset": 250,
+ "vOffset": 100,
+ "alignment": "center",
+ "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
+ }
+}}
+
+The same text expressed as XML:
+
+
+ on
+
+ main_window
+ 500
+ 500
+
+
+ 250
+ 250
+ center
+
+
+ text1
+ 250
+ 100
+ center
+
+ sun1.opacity = (sun1.opacity / 100) * 90;
+
+
+
+
+{"web-app": {
+ "servlet": [
+ {
+ "servlet-name": "cofaxCDS",
+ "servlet-class": "org.cofax.cds.CDSServlet",
+ "init-param": {
+ "configGlossary:installationAt": "Philadelphia, PA",
+ "configGlossary:adminEmail": "ksm@pobox.com",
+ "configGlossary:poweredBy": "Cofax",
+ "configGlossary:poweredByIcon": "/images/cofax.gif",
+ "configGlossary:staticPath": "/content/static",
+ "templateProcessorClass": "org.cofax.WysiwygTemplate",
+ "templateLoaderClass": "org.cofax.FilesTemplateLoader",
+ "templatePath": "templates",
+ "templateOverridePath": "",
+ "defaultListTemplate": "listTemplate.htm",
+ "defaultFileTemplate": "articleTemplate.htm",
+ "useJSP": false,
+ "jspListTemplate": "listTemplate.jsp",
+ "jspFileTemplate": "articleTemplate.jsp",
+ "cachePackageTagsTrack": 200,
+ "cachePackageTagsStore": 200,
+ "cachePackageTagsRefresh": 60,
+ "cacheTemplatesTrack": 100,
+ "cacheTemplatesStore": 50,
+ "cacheTemplatesRefresh": 15,
+ "cachePagesTrack": 200,
+ "cachePagesStore": 100,
+ "cachePagesRefresh": 10,
+ "cachePagesDirtyRead": 10,
+ "searchEngineListTemplate": "forSearchEnginesList.htm",
+ "searchEngineFileTemplate": "forSearchEngines.htm",
+ "searchEngineRobotsDb": "WEB-INF/robots.db",
+ "useDataStore": true,
+ "dataStoreClass": "org.cofax.SqlDataStore",
+ "redirectionClass": "org.cofax.SqlRedirection",
+ "dataStoreName": "cofax",
+ "dataStoreDriver": "com.microsoft.jdbc.sqlserver.SQLServerDriver",
+ "dataStoreUrl": "jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon",
+ "dataStoreUser": "sa",
+ "dataStorePassword": "dataStoreTestQuery",
+ "dataStoreTestQuery": "SET NOCOUNT ON;select test='test';",
+ "dataStoreLogFile": "/usr/local/tomcat/logs/datastore.log",
+ "dataStoreInitConns": 10,
+ "dataStoreMaxConns": 100,
+ "dataStoreConnUsageLimit": 100,
+ "dataStoreLogLevel": "debug",
+ "maxUrlLength": 500}},
+ {
+ "servlet-name": "cofaxEmail",
+ "servlet-class": "org.cofax.cds.EmailServlet",
+ "init-param": {
+ "mailHost": "mail1",
+ "mailHostOverride": "mail2"}},
+ {
+ "servlet-name": "cofaxAdmin",
+ "servlet-class": "org.cofax.cds.AdminServlet"},
+
+ {
+ "servlet-name": "fileServlet",
+ "servlet-class": "org.cofax.cds.FileServlet"},
+ {
+ "servlet-name": "cofaxTools",
+ "servlet-class": "org.cofax.cms.CofaxToolsServlet",
+ "init-param": {
+ "templatePath": "toolstemplates/",
+ "log": 1,
+ "logLocation": "/usr/local/tomcat/logs/CofaxTools.log",
+ "logMaxSize": "",
+ "dataLog": 1,
+ "dataLogLocation": "/usr/local/tomcat/logs/dataLog.log",
+ "dataLogMaxSize": "",
+ "removePageCache": "/content/admin/remove?cache=pages&id=",
+ "removeTemplateCache": "/content/admin/remove?cache=templates&id=",
+ "fileTransferFolder": "/usr/local/tomcat/webapps/content/fileTransferFolder",
+ "lookInContext": 1,
+ "adminGroupID": 4,
+ "betaServer": true}}],
+ "servlet-mapping": {
+ "cofaxCDS": "/",
+ "cofaxEmail": "/cofaxutil/aemail/*",
+ "cofaxAdmin": "/admin/*",
+ "fileServlet": "/static/*",
+ "cofaxTools": "/tools/*"},
+
+ "taglib": {
+ "taglib-uri": "cofax.tld",
+ "taglib-location": "/WEB-INF/tlds/cofax.tld"}}}
+
+The same file expressed as XML:
+
+
+
+
+
+
+
+ cofaxCDS
+
+
+ org.cofax.cds.CDSServlet
+
+
+
+ configGlossary:installationAt
+ Philadelphia, PA
+
+
+ configGlossary:adminEmail
+ ksm@pobox.com
+
+
+ configGlossary:poweredBy
+ Cofax
+
+
+ configGlossary:poweredByIcon
+ /images/cofax.gif
+
+
+ configGlossary:staticPath
+ /content/static
+
+
+
+ templateProcessorClass
+ org.cofax.WysiwygTemplate
+
+
+
+ templateLoaderClass
+ org.cofax.FilesTemplateLoader
+
+
+
+ templatePath
+ templates
+
+
+
+ templateOverridePath
+
+
+
+
+ defaultListTemplate
+ listTemplate.htm
+
+
+
+ defaultFileTemplate
+ articleTemplate.htm
+
+
+
+ useJSP
+ false
+
+
+
+ jspListTemplate
+ listTemplate.jsp
+
+
+
+ jspFileTemplate
+ articleTemplate.jsp
+
+
+
+ cachePackageTagsTrack
+ 200
+
+
+
+ cachePackageTagsStore
+ 200
+
+
+
+ cachePackageTagsRefresh
+ 60
+
+
+
+ cacheTemplatesTrack
+ 100
+
+
+
+ cacheTemplatesStore
+ 50
+
+
+
+ cacheTemplatesRefresh
+ 15
+
+
+
+ cachePagesTrack
+ 200
+
+
+
+ cachePagesStore
+ 100
+
+
+
+ cachePagesRefresh
+ 10
+
+
+
+ cachePagesDirtyRead
+ 10
+
+
+
+ searchEngineListTemplate
+ forSearchEnginesList.htm
+
+
+
+ searchEngineFileTemplate
+ forSearchEngines.htm
+
+
+
+ searchEngineRobotsDb
+ WEB-INF/robots.db
+
+
+
+ useDataStore
+ true
+
+
+
+ dataStoreClass
+ org.cofax.SqlDataStore
+
+
+
+ redirectionClass
+ org.cofax.SqlRedirection
+
+
+ dataStoreName
+ cofax
+
+
+
+ dataStoreDriver
+ com.microsoft.jdbc.sqlserver.SQLServerDriver
+
+
+
+ dataStoreUrl
+ jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon
+
+
+
+ dataStoreUser
+ sa
+
+
+
+ dataStorePassword
+
+
+
+
+ dataStoreTestQuery
+ SET NOCOUNT ON;select test='test';
+
+
+
+ dataStoreLogFile
+ /usr/local/tomcat/logs/datastore.log
+
+
+
+ dataStoreInitConns
+ 10
+
+
+
+ dataStoreMaxConns
+ 100
+
+
+
+ dataStoreConnUsageLimit
+ 100
+
+
+ dataStoreLogLevel
+ debug
+
+
+
+ maxUrlLength
+ 500
+
+
+
+
+
+
+ cofaxEmail
+
+
+ org.cofax.cds.EmailServlet
+
+
+
+ mailHost
+ mail1
+
+
+
+ mailHostOverride
+ mail2
+
+
+
+
+
+ cofaxAdmin
+
+
+ org.cofax.cds.AdminServlet
+
+
+
+
+
+ fileServlet
+
+
+ org.cofax.cds.FileServlet
+
+
+
+
+
+ cofaxTools
+
+
+ org.cofax.cms.CofaxToolsServlet
+
+
+
+ templatePath
+ toolstemplates/
+
+
+
+ log
+ 1
+
+
+
+ logLocation
+ /usr/local/tomcat/logs/CofaxTools.log
+
+
+
+ logMaxSize
+
+
+
+
+ dataLog
+ 1
+
+
+
+ dataLogLocation
+ /usr/local/tomcat/logs/dataLog.log
+
+
+
+ dataLogMaxSize
+
+
+
+
+ removePageCache
+ /content/admin/remove?cache=pages&id=
+
+
+
+ removeTemplateCache
+ /content/admin/remove?cache=templates&id=
+
+
+
+ fileTransferFolder
+ /usr/local/tomcat/webapps/content/fileTransferFolder
+
+
+
+ lookInContext
+ 1
+
+
+
+ adminGroupID
+ 4
+
+
+
+ betaServer
+ true
+
+
+
+
+
+
+ cofaxCDS
+
+
+ /
+
+
+
+
+
+ cofaxEmail
+
+
+ /cofaxutil/aemail/*
+
+
+
+
+
+ cofaxAdmin
+
+
+ /admin/*
+
+
+
+
+
+ fileServlet
+
+
+ /static/*
+
+
+
+
+
+ cofaxTools
+
+
+ /tools/*
+
+
+
+
+ cofax.tld
+ /WEB-INF/tlds/cofax.tld
+
+
+
+
+
+The action and label values only need to be provided if they are not the same as the id.
+
+{"menu": {
+ "header": "SVG Viewer",
+ "items": [
+ {"id": "Open"},
+ {"id": "OpenNew", "label": "Open New"},
+ null,
+ {"id": "ZoomIn", "label": "Zoom In"},
+ {"id": "ZoomOut", "label": "Zoom Out"},
+ {"id": "OriginalView", "label": "Original View"},
+ null,
+ {"id": "Quality"},
+ {"id": "Pause"},
+ {"id": "Mute"},
+ null,
+ {"id": "Find", "label": "Find..."},
+ {"id": "FindAgain", "label": "Find Again"},
+ {"id": "Copy"},
+ {"id": "CopyAgain", "label": "Copy Again"},
+ {"id": "CopySVG", "label": "Copy SVG"},
+ {"id": "ViewSVG", "label": "View SVG"},
+ {"id": "ViewSource", "label": "View Source"},
+ {"id": "SaveAs", "label": "Save As"},
+ null,
+ {"id": "Help"},
+ {"id": "About", "label": "About Adobe CVG Viewer..."}
+ ]
+}}
+
+The same message expressed as XML:
+
+
+
+We have discussed qsort() in C. C++ STL provides a similar function sort that sorts a vector or array (items with random access)
+
+It generally takes two parameters, the first one being the point of the array/vector from where the sorting needs to begin and the second parameter being the length up to which we want the array/vector to get sorted. The third parameter is optional and can be used in cases such as if we want to sort the elements lexicographically.
+
+By default, the sort() function sorts the elements in ascending order.
+
+Below is a simple program to show the working of sort().
+
+// C++ program to demonstrate default behaviour of
+// sort() in STL.
+#include
+using namespace std;
+
+int main()
+{
+ int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
+ int n = sizeof(arr) / sizeof(arr[0]);
+
+ /*Here we take two parameters, the beginning of the
+ array and the length n upto which we want the array to
+ be sorted*/
+ sort(arr, arr + n);
+
+ cout << "\nArray after sorting using "
+ "default sort is : \n";
+ for (int i = 0; i < n; ++i)
+ cout << arr[i] << " ";
+
+ return 0;
+}
+Output
+
+Array after sorting using default sort is :
+0 1 2 3 4 5 6 7 8 9
+
+Time Complexity: O(N log N)
+Auxiliary Space: O(1)
+
+How to sort in descending order?
+sort() takes a third parameter that is used to specify the order in which elements are to be sorted. We can pass the “greater()” function to sort in descending order. This function does a comparison in a way that puts greater elements before.
+
+// C++ program to demonstrate descending order sort using
+// greater<>().
+#include
+using namespace std;
+
+int main()
+{
+ int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
+ int n = sizeof(arr) / sizeof(arr[0]);
+
+ sort(arr, arr + n, greater());
+
+ cout << "Array after sorting : \n";
+ for (int i = 0; i < n; ++i)
+ cout << arr[i] << " ";
+
+ return 0;
+}
+Output
+
+Array after sorting :
+9 8 7 6 5 4 3 2 1 0
+
+Time Complexity: O(N log N)
+Auxiliary Space: O(1)
+
+Sort the array only in the given range: To deal with such types of problems we just have to mention the range inside the sort function.
+Below is the implementation of above case:
+
+// C++ program to demonstrate sort()
+
+#include
+using namespace std;
+
+int main()
+{
+ int arr[] = { 0, 1, 5, 8, 9, 6, 7, 3, 4, 2 };
+ int n = sizeof(arr) / sizeof(arr[0]);
+
+ // Sort the elements which lies in the range of 2 to
+ // (n-1)
+ sort(arr + 2, arr + n);
+
+ cout << "Array after sorting : \n";
+ for (int i = 0; i < n; ++i)
+ cout << arr[i] << " ";
+
+ return 0;
+}
+// This code is contributed by Suruchi Kumari
+Output
+
+Array after sorting :
+0 1 2 3 4 5 6 7 8 9
+
+Time Complexity: O(N log N)
+
+Auxiliary Space: O(1)
+
+How to sort in a particular order?
+We can also write our own comparator function and pass it as a third parameter. This “comparator” function returns a value; convertible to bool, which basically tells us whether the passed “first” argument should be placed before the passed “second” argument or not.
+For eg: In the code below, suppose intervals {6,8} and {1,9} are passed as arguments in the “compareInterval” function(comparator function). Now as i1.first (=6) < i2.first (=1), so our function returns “false”, which tells us that “first” argument should not be placed before “second” argument and so sorting will be done in order like {1,9} first and then {6,8} as next.
+
+// A C++ program to demonstrate
+// STL sort() using
+// our own comparator
+#include
+using namespace std;
+
+// An interval has a start
+// time and end time
+struct Interval {
+ int start, end;
+};
+
+// Compares two intervals
+// according to starting times.
+bool compareInterval(Interval i1, Interval i2)
+{
+ return (i1.start < i2.start);
+}
+
+int main()
+{
+ Interval arr[]
+ = { { 6, 8 }, { 1, 9 }, { 2, 4 }, { 4, 7 } };
+ int n = sizeof(arr) / sizeof(arr[0]);
+
+ // sort the intervals in increasing order of
+ // start time
+ sort(arr, arr + n, compareInterval);
+
+ cout << "Intervals sorted by start time : \n";
+ for (int i = 0; i < n; i++)
+ cout << "[" << arr[i].start << "," << arr[i].end
+ << "] ";
+
+ return 0;
+}
+Output
+
+Intervals sorted by start time :
+[1,9] [2,4] [4,7] [6,8]
+
+The time complexity of std::sort() is:
+
+ Best Case – O(N log N)
+ Average Case – O(N log N)
+ Worst-Case – O(N log N)
+
+Space Complexity: It may use O( log N) auxiliary space.
+
+#include
+#include
+using namespace std;
+
+template
+class Comparator { // we pass an object of this class as
+ // third arg to sort function...
+public:
+ bool operator()(T x1, T x2)
+ {
+ return x1 < x2;
+ }
+};
+
+template bool funComparator(T x1, T x2)
+{ // return type is bool
+ return x1 <= x2;
+}
+
+void show(int a[], int array_size)
+{
+ for (int i = 0; i < array_size; i++) {
+ cout << a[i] << " ";
+ }
}
-class SwiftMethod < SwiftEntityElement
-end
+int main()
+{
+ int a[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
+ int asize = sizeof(a) / sizeof(int);
+ cout << "The array before sorting is : ";
+ show(a, asize);
+ cout << endl << "The array after sorting is(asc) :";
+ sort(a, a + asize);
+ show(a, asize);
+ cout << endl << "The array after sorting is(desc) :";
+ sort(a, a + asize, greater());
+ show(a, asize);
+ cout << endl
+ << "The array after sorting is(asc but our "
+ "comparator class) :";
+ sort(a, a + asize, Comparator());
+ show(a, asize);
+ cout << endl
+ << "The array after sorting is(asc but our "
+ "comparator function) :";
+ sort(a, a + asize, funComparator);
+ show(a, asize);
+
+ return 0;
+}
+Output
-Co-Op program helps wounded warriors transition
+The array before sorting is : 1 5 8 9 6 7 3 4 2 0
+The array after sorting is(asc) :0 1 2 3 4 5 6 7 8 9
+The array after sorting is(desc) :9 8 7 6 5 4 3 2 1 0
+The array after sorting is(asc but our comparator class) :0 1 2 3 4 5 6 7 8 9
+The array after sorting is(asc but our comparator function) :0 1 2 3 4 5 6 7 8 9
-Story Highlights
+Time Complexity: O(N log N)
+Auxiliary Space: O(1)
-Former Staff Sgt. Anthony Moralez was placed in a civilian position at White Sands Missile Range thanks to the Wounded Warrior Co-Op Program.
+Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
-Former Staff Sgt. Anthony Moralez was placed in a civilian position at White Sands Missile Range thanks to the Wounded Warrior Co-Op Program.
+The following are different ways to construct or initialize a vector in C++ STL
-WHITE SANDS MISSILE RANGE, N.M., Nov. 5, 2009 - White Sands Missile Range has initiated a Wounded Warrior Co-Op Program to help expedite recruitment efforts while at the same time helping Soldiers transition to civilian life.
+1. Initializing by pushing values one by one:
-Former Staff Sgt. Anthony Moralez was assigned by the battalion to work with CPAC to help develop the program. He was subsequently placed in a civilian position.
+// C++ program to create an empty
+// vector and push values one
+// by one.
+#include
+#include
+using namespace std;
-"This program is something I'm very passionate about," Moralez said. He explained that not too long ago he was sitting in the WTU wondering what life had in store for him. "Quite honestly I was worried!" he said.
+int main()
+{
+ // Create an empty vector
+ vector vect;
-Then last year he met the EEO and CPAC office staff and he said they were extremely passionate about helping the Soldiers "Give back". When he was approached to help with the startup of the program Moralez said he jumped at the opportunity. While developing the concept plan, Moralez said he realized that the program will only work if the individual wants it to work and is willing to give up a few things to gain others.
+ vect.push_back(10);
+ vect.push_back(20);
+ vect.push_back(30);
-"I feel good about the program for two reasons, I helped develop it and it worked for me," Moralez said. "I'm telling you, if you walk through this door many others will open. The trick is to get thru that first one!"
+ for (int x : vect)
+ cout << x << " ";
-Soldiers eligible for this program are those in the battalion who are transitioning out of the Army. Those Soldiers who apply for the program, with an endorsement from the Warrior Transition Battalion commander, can be placed in a federal civilian position at White Sands Missile Range for up to 90 days, pending release from active duty.
+ return 0;
+}
+Output
-Upon successful completion of the trial period and upon honorable release from the military, if approved by the appropriate civilian selecting official, the eligible Soldier may be appointed to the civilian position.
+10 20 30
-"Tony has been an outstanding addition to DPTMS. If you're looking for adaptive, resourceful self-starters with good operational sense, look to the Wounded Warrior Program. I just found out I have two more openings and I plan to bring in two more," said Gerry Veara, White Sands DPTMS.
+2. Specifying size and initializing all values:
-According to Sally Smoot, White Sands CPAC director at the time this article was written, the program is a win-win situation. "Our managers get to fill their jobs quickly, and we get to take care of our Soldiers who have taken care of us."
+// C++ program to create an empty
+// vector and push values one
+// by one.
+#include
+#include
+using namespace std;
-"Under the Equal Employment Opportunity umbrella, the Wounded Warrior Co-Op Program fits well into the objectives of the Disabled Veterans Affirmative Action Program Plan. Those warriors who are a part of the Wounded Warrior Battalion have combat related disabilities they received while serving in the war on terrorism," said Liz Childers, EEO officer.
+int main()
+{
+ int n = 3;
-Childers said it is the goal of the EEO office to ensure that disabled veterans are offered equal employment opportunity in the federal service. "With the collaborated effort of the Civilian Personnel Advisory Center and William Beaumont Army Medical Center, the objective is to recruit and employ those wounded warriors with the required skills needed to fulfill the mission of White Sands Missile Range," she said.
+ // Create a vector of size n with
+ // all values as 10.
+ vector vect(n, 10);
-Applications for this Program are available online at www.wsmr.army.mil/employment.
+ for (int x : vect)
+ cout << x << " ";
-Questions pertaining to this Program may be directed to Carol Main at (575) 678-7728, DSN 258-7728.
-Q:
+ return 0;
+}
+Output
-New column from previous columns in Pandas
+10 10 10
-I have a pandas dataframe with some columns:
->>data.columns.values
-array(['Sheet', 'Row', 'Column', 'Cell', 'V0', 'Thx', 'dV', 'Vd'], dtype=object)
+3. Initializing like arrays:
-Each row contains a different value for the Sheet, Row, etc etc.
-From the info of Sheet, Row, etc I will create a PDF file title like this:
-title = Sheet%s_Row%s_Column%s_Cell%s.pdf
-So instead of iterating over each row of the DataFrame and create a single title each time, I wanted to directly create another column of strings called title and store the different titles like this:
-data['title'] = "Sheet%s_Row%s_Column%s_Cell%s" % (data['Sheet'], data['Row'], data['Column'], data['Cell'])
-But this is not working, seems like it is appending each Serie inside each %s
-How can I create this title column from the info on each row without having to iterate over the entire DataFrame?
+// C++ program to initialize
+// a vector like an array.
+#include
+#include
+using namespace std;
-A:
+int main()
+{
+ vector vect{ 10, 20, 30 };
-One way to do this would be using DataFrame.apply() with axis=1. Example -
-data['title'] = data.apply(lambda row: "Sheet{}_Row{}_Column{}_Cell{}".format(row['Sheet'], row['Row'], row['Column'], row['Cell']) , axis=1)
+ for (int x : vect)
+ cout << x << " ";
-Demo -
-In [52]: df = pd.DataFrame([['A','B'],['C','D'],['E','F']] , columns=['Sheet','row'])
+ return 0;
+}
+Output
-In [53]: df
-Out[53]:
- Sheet row
-0 A B
-1 C D
-2 E F
+10 20 30
-In [54]: df['title'] = df.apply(lambda row: "Sheet{}_row{}".format(row['Sheet'],row['row']) , axis=1)
+4. Initializing from an array:
-In [55]: df
-Out[55]:
- Sheet row title
-0 A B SheetA_rowB
-1 C D SheetC_rowD
-2 E F SheetE_rowF
+// C++ program to initialize
+// a vector from an array.
+#include
+#include
+using namespace std;
+int main()
+{
+ int arr[] = { 10, 20, 30 };
+ int n = sizeof(arr) / sizeof(arr[0]);
-The Joker (1960 film)
+ vector vect(arr, arr + n);
-The Joker () is a 1960 French comedy film directed by Philippe de Broca.
+ for (int x : vect)
+ cout << x << " ";
-Plot
-Edouard Berlon is a young, incorrigible seducer who moves very lightly from one affair to the next. He meets Helene Larouch, a woman married to André, a rich financier who is very busy with his affairs, leaving her in an emotionally arid life. Initially Helene resists Edouard's wooing, but as she gets to know his lively character, his eccentric lifestyle and his very unusual family environment, including his old uncle Théodose, his brother Pilou, servat Olga, some infants, and a few stray dogs, she lets herself become seduced. Their relation, however, turns out to be an ephemeral one as Edouard is busy seducing another woman.
+ return 0;
+}
+Output
-Cast
+10 20 30
- Anouk Aimée as Helene Larouch
- Jean-Pierre Cassel as Edouard Berlon
- Pierre Palau as Théodose
- Geneviève Cluny as Pilou Berlon
- Georges Wilson as Guillaume Berlon
- Anne Tonietti as Olga
- François Maistre as André Laroche
- Jean-Pierre Rambal as Paul
- Liliane Patrick as Solange
- Irène Chabrier as Aline, servant at the inn
+5. Initializing from another vector:
-Release
-The film had its premiere at the Locarno Film Festival in August 1960, but was not released commercially until 20 January 1961 in France and 7 August 1961 in New York. During the 2012 Cannes Film Festival, the film was presented with other classics at the Cinéma de la Plage, a non-competitive part of the official selection that is open to the public. In 12 November 2013, the film was presented at the Cinémathèque québécoise, Montréal.
+// C++ program to initialize a vector from
+// another vector.
+#include
+#include
+using namespace std;
-Critical response
-The film has been described as "a lot of genial fun" as the plot evolves. It also has been described as whimsical and in parts "nutty" for the eccentric lifestyle of the hero and his family. French critics, on the other hand, find subtle qualities in the presentation of the characters as uncle Théodose is described as "an original, old uncle" as well as poetic connotations in the overall work.
+int main()
+{
+ vector vect1{ 10, 20, 30 };
-References
+ vector vect2(vect1.begin(), vect1.end());
-External links
+ for (int x : vect2)
+ cout << x << " ";
-Category:1961 films
-Category:French films
-Category:French-language films
-Category:1960s romantic comedy films
-Q:
+ return 0;
+}
+Output
-C General sscanf return
+10 20 30
-I'm trying to use the return value of sscanf function. The problem is that in the file that I'm reading, some lines may contain different number of integers. How can I tackle this problem?
+6. Initializing all elements with a particular value:
-A:
+// C++ Program to initialize vector using fill()
+#include
+#include
+using namespace std;
-int values[5];
-int values_per_line = sscanf_s(line_buffer, "%d %d %d %d %d", &values[0], &values[1], &values[2], &values[3], &values[4]);
+int main()
+{
+ // creating array with size 10
+ vector vect1(10);
-`
-sscanf_s, _sscanf_s_l, swscanf_s, _swscanf_s_l:
+ // initializing using fill() function
+ int value = 5;
+ fill(vect1.begin(), vect1.end(), value);
-Return Value
-Each of these functions [including s_sscanf()] returns the number of fields that are successfully converted and assigned; the return value does not include fields that were read but not assigned. A return value of 0 indicates that no fields were assigned. The return value is EOF for an error or if the end of the string is reached before the first conversion.
+ // printing vector
+ for (int x : vect1)
+ cout << x << " ";
+ return 0;
+}
+Output
-The Decision Maker
+5 5 5 5 5 5 5 5 5 5
-Credit unions are well aware of the growing revolution in payments. A recent report by McKinsey & Company (Global Payments 2015: A Healthy Industry Confronts Disruption) noted that, the growth of nonbank digital competitors over the next five years will increase downward pressure on transaction margins while increasing growth in electronic payments.
+7. Initialize an array with consecutive numbers using std::iota:
-The drivers for this trend are all too familiar:
+// C++ program to initialize a
+// vector with consecutive
+// numbers
+#include
+#include
+#include
+using namespace std;
-Large technology companies such as Apple, Google, Facebook, Amazon, Microsoft, Tencent and Alibaba, are some of the most significant nonbank competitors. These organizations are cash-rich and have virtually captive customer bases.
+int main()
+{
+ // declaring a vector with size 5
+ vector vec(5);
-Smartphones have become a crucial channel in the world of payments. With these devices comes a swarm of payment options. These range from the likes of Apple Pay to “In-App” purchases that provide an almost seamless user experience.
+ // initializing using iota()
+ iota(vec.begin(), vec.end(), 1);
-Member expectations for technology-enabled experiences have grown considerably. Today’s members, like any other consumers, have experienced an unprecedented level of service via nonbank providers. Some may wonder why their favorite credit union does not have the same level of digital service.
+ // printing the vector
+ for (int i = 0; i < 5; i++) {
+ cout << vec[i] << " ";
+ }
+ return 0;
+}
+Output
-Despite all the hype about the electronics payments, adoption by credit union members may tend to be slower than the public at large. Members tend to be more conservative so fewer are likely to be enthusiastic early adopters.
+1 2 3 4 5
-However, this does not mean credit unions are complacent about this growing trend. The industry, especially its larger players, has begun to respond vigorously with various “digital wallet” strategies. While these efforts are in the formative stages, it is imperative that credit unions position themselves to members as the trusted alternative for safe and secure digital payments. From this positioning, members can be educated and motivated to become loyal users of the credit union’s digital payment platform.
+Time complexity: O(N), where N is the size of the vector.
-A crucial element to make this strategy successful is analytics. Making effective decisions in this fast-paced environment is crucial. The ability to adjust the tactical underpinnings of the strategy on a monthly, weekly, or even daily basis depends on the availability of transactional data for analysis. Having data quickly available at this level of granularity requires a well-designed and well-tuned data warehouse. This tool provides an essential feedback loop for decision makers as they guide the digital payments strategy toward meeting member needs and keeping those payments (and their margins) close to the credit union.
+Auxiliary space: O(N).
-We are missing an opportunity in this space. I would suggest that digital wallets and the associated strategies for a credit union implementation are great and should be pursued. As an industry however, we should own the entire transaction stack from the rails to the transaction. Our mobile transaction rails currently are owned and controlled by companies that are not credit union friendly. Additionally, the advent of blockchain technology will push massive disruption at the current banking infrastructure. Some have predicted the complete demise of banking as it currently exists as a result. Bottom line is the industry is fast approaching the need to innovate or die in my view. With that in mind, there is new pursuit of solutions that address both lines of thinking. Unfortunately, as an industry we remain focused on the wrong things. Instead, we need to think much bigger.
+If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.
-Subscribe to Email Updates
+Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!
-You now have more information at hand about your credit union than ever before. But are you using it to "out-think" your rivals? If not, you may be missing out on a potent competitive tool.
-This blog will:
+How to Hide and Show a Console Window in C++?
+Read
+Discuss
+Courses
+Practice
-Educate subscribers about data integration and Big Data and Analytics.
-Send this page to someone via email
+The task is to hide and Show the console window of a C++ program. The program for the same is given below.
-WARNING: The following story contains descriptions that some readers may find disturbing. Discretion is advised.
+ Note: The results of the following program can only be seen when it is executed on a console.
-Quebec City police say a 39-year-old man has been arrested in connection with what they are describing as an attempted murder of a woman in her 20s.
+Example:
-The incident happened on Friday evening when police were called to Arago Street West at around 9 p.m. after a man set a woman on fire before fleeing the scene.
+// C++ program to hide and show a console window
+#include
+#include
-Paramedics rushed the woman to hospital with life-threatening injuries.
+using namespace std;
-READ MORE: Man seriously injured after setting himself on fire outside south London government office, SIU says
+void countdown()
+{
+ cout << "3" << endl;
+ Sleep(1000);
+ cout << "2" << endl;
+ Sleep(1000);
+ cout << "1" << endl;
+ Sleep(1000);
+ cout << "0" << endl;
+}
-Police say she suffered serious burns to her face, back and hands.
+int main()
+{
+ countdown();
+ HWND window;
+ AllocConsole();
+ // You Can Find HANDLE of other windows too
+ window = FindWindowA("ConsoleWindowClass", NULL);
+ ShowWindow(window, 0);
+
+ countdown();
+ ShowWindow(window, 1);
+}
-“We fear for her life,” police said in a written statement on Saturday.
+Output:
-Story continues below advertisement
-The suspect was arrested Saturday morning at around 11:35 a.m. on Girardin Street in Drummondville, roughly 150 kilometres west of Quebec City.
-Quebec City police spokesperson Etienne Doyon said the suspect was the victim’s ex.
+Explanation: The above program counts from 3 to 1 before the Console Window disappears. After the window has disappeared, the ShowWindow helps the program so that the Console Window reappears again after counting from 3 to 1(executing the countdown function).
-READ MORE: Multiple injuries after vehicle crashes into Quebec City building
+The execution of the program can be understood by understanding the key functions of the program.
-Doyon said a warrant had been issued for his arrest. He was wanted for attempted murder and aggravated assault.
+ #include – The windows.h header in C++ programming languages are specifically designed for windows and contain a very large number of windows specific functions.
+ AllocConsole()- AllocConsole initializes standard input, standard output, and standard error handles for the new console.
+ ShowWindow()- Sets the specified window’s show state.
+ FindWindowA()– Takes string parameters and checks whose class name and window name match the specified strings
-He is being held by provincial police in Drummondville.
+Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!
-Investigators with Quebec City police were en route to interview the suspect.
+Last Updated : 27 Nov, 2022
-Doyon said police had yet to interview the victim herself.
+Prerequisite: Templates in C++
-He confirmed reports that the woman’s mother and children had witnessed the attack.
+Substitution Failure Is Not An Error (SFINAE) is a principle of the C++ programming language that states that a compiler should not fail to compile a program just because it cannot substitute a template parameter. This principle allows for the use of template metaprogramming and enables the compiler to make decisions based on the types of template arguments, which can be useful when dealing with complex code and difficult to reason about logic.
-“The children were placed in the care of the grandmother,” he said, adding that police made sure they were being provided with the necessary support.
+At its core, SFINAE is a way of allowing a compiler to decide which template to use in a given context. The decision is based on the types of template arguments and the compiler will choose the template that is most appropriate for the arguments.
+Advantages of SFINAE:
-Martyn Allard, who says he’s the victim’s neigbour, told Global News he was standing on his second-floor balcony Friday night when he saw someone running by.
+ SFINAE is useful in a variety of scenarios, including writing generic code and dealing with complex logic.
+ SFINAE allows the compiler to decide which template to use, it allows programmers to write code that can be reused in different contexts without needing to explicitly specify the types of template parameters.
+ SFINAE allows for better code reuse, as the same code can be used for different types of objects and parameters.
+ SFINAE also allows for better control over code complexity by allowing the compiler to make decisions based on the types of template parameters, it can reduce the amount of complex logic that needs to be written and understood.
+ SFINAE helps to make code more readable and maintainable, as it is easier to follow the logic of the program.
-“I thought he’d dropped a burning torch on the street,” he said, adding he only realized it was a person when she started running and screaming, “I’m on fire, I’m on fire, someone lit me on fire!”
+In conclusion, SFINAE is a powerful concept in C++ programming that allows for better code reuse, improved code readability, and better control over code complexity. It is a key component of template metaprogramming and is an essential tool for writing robust and efficient code.
-Story continues below advertisement
+Example:
-READ MORE: Evacuation at Quebec City airport terminal lifted, operations return to normal
+// C++ Program to implement
+// Substitution Failure Is Not An Error
+#include
+#include
-Allard said he called 911 and then rushed to the woman’s side to try and help her.
+using namespace std;
-“I was yelling at her ‘Madame get on the ground, madame get on the ground,’ but she was burning up like a torch,” he said.
+// USing template to avoid errors
+template
+void print_type(T t)
+{
+ // For integer
+ if (is_integral::value) {
+ cout << "T is an integral type" << endl;
+ }
-He described a strong smell of gasoline as he approached the victim and said he ripped her burning clothes off as he waited for a neighbour to bring a blanket.
+ // For floating number
+ else if (is_floating_point::value) {
+ cout << "T is a floating point type" << endl;
+ }
-Allard said he grasped the victim’s hands as she appeared wobbly and talked to her to keep her alert.
+ // All other
+ else {
+ cout << "T is not an integral"
+ << "or floating point type" << endl;
+ }
+}
-“She was talking about her kids,” he said.
+// Driver Code
+int main()
+{
+ // T is an integral type
+ print_type(10);
-Story continues below advertisement
+ // T is a floating point type
+ print_type(10.5f);
-— With files from The Canadian Press
-CCSU professors accused of sexual misconduct with students
+ // T is an integral type
+ print_type(true);
-Photo: Journal Register Co. Photo: Journal Register Co. Image 1 of / 3 Caption Close CCSU professors accused of sexual misconduct with students 1 / 3 Back to Gallery
+ // T is an integral type
+ print_type('a');
-Central Connecticut State University President Zulma R. Toro announced Tuesday that she is seeking to fire two longtime theater professors after investigators concluded that each had likely engaged in sexual misconduct with one or more students.
+ // T is not an integral
+ // or floating point type
+ print_type("GFG");
-Toro also announced plans to appoint new leadership for the university’s Office of Diversity & Equity and to reorganize the human resources department after evidence showed that administrators for years failed to take proper action on complaints of sexual misconduct.
+ return 0;
+}
+Output
-The two professors are Joshua Perlstein, hired in 1992, who was placed on paid administrative leave in April, and Thomas Delventhal, who was hired in 1998 and was placed on paid leave last week. Both professors continue to draw their salaries, which are in the $100,000 range.
+T is an integral type
+T is a floating point type
+T is an integral type
+T is an integral type
+T is not an integralor floating point type
-“I am disgusted and disheartened by the new findings indicating two of our professors repeatedly engaged in sexual misconduct and inappropriate behavior with their students,” Toro said in statement. “Also disturbing are the apparent failures by administrators who, over the years, did not protect our students. The findings pinpoint vital changes that are needed to ensure past misbehaviors, mistakes and inaction are not repeated at this university.”
+In this example, the print_type() function is a template function that takes a single argument of type T. Inside the function, there are if statements that use the is_integral and is_floating_point type traits to check the type of T. If T is of the expected type, the corresponding branch of the if statement is executed and the appropriate message is printed. If T is not of the expected type, the else branch is executed and the message “T is not an integral or floating point type” is printed.
-Toro hired the Hartford law firm Shipman & Goodwin LLP nine months ago to conduct the investigation after an article appeared in CCSU’s student newspaper, The Recorder, revealing allegations of sexual misconduct by Perlstein. The same article also detailed a lack of administrative action when complaints were made.
+SFINAE is used in this example because the if statement uses type traits to check the type of T, and if T is not of the expected type, the template substitution will fail. However, because SFINAE is in effect, this failure is not treated as a compile-time error, and the else branch is executed instead.
+Disadvantages of SFINAE
-The investigation, which entailed reviewing thousands of documents, emails, and texts and interviews with dozens of faculty, staff and current and former students, found significant evidence that Perlstein was likely involved in sexual misconduct with several students, including a lengthy, manipulative relationship with one student that continued after her graduation.
+Although SFINAE is very useful it comes with its own limitations, these are :
-It also found that he had a “history of questionable interactions” with female students, was untruthful to investigators and attempted to conceal his problematic conduct because he believed it would put his job in jeopardy.
+ It can be difficult to debug and understand the underlying code, as it relies heavily on the templates and multiple overloads to work correctly.
+ SFINAE is not widely used and can be difficult to find documentation and tutorials for.
+ SFINAE can produce unexpected behavior, as it relies on the compiler to determine which template to use based on the given types. This can lead to unexpected results if the compiler chooses the wrong template.
+ SFINAE can also be slow, as it involves multiple checks in order to determine the correct template. This can lead to a performance hit if used in a critical section of code.
-Following up on students’ complaints about Delventhal, the investigators said that he admitted, over the years, to kissing five students on the neck and/or forehead, was untruthful during his investigatory interview, and denied attempting to engage in any relationship with current or former students.
+There are other methods to perform the same task one of which is enable_if
+Enable_if (Syntax)
-Perlstein said Tuesday he had “no comment at this time,” while Delventhal could not be reached for comment.
+template
+enable_if_t, void> f(T x)
+{
+ // code that only applies to integral tmodule jinvertertb;
+ reg a;
+ wire y;
+
+ //Design Instance
+ jinverter jinv(y,a);
+
+ initial
+ begin
+ $display ("RESULT\ta\ty");
+
+ a = 1; # 100; // Another value
+ if ( y == 0 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 0; # 100; // Initial value is set
+ if ( y == 1 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 1; # 50; // Another value
+ if ( y == 0 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 0; # 100; // Initial value is set
+ if ( y == 1 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ end
+
+ //enabling the wave dump
+ initial begin
+ $dumpfile("dump.vcd"); $dumpvars;
+ end
+endmoduleypes goes here
+}
-Toro said she is taking the steps required by collective bargaining to dismiss both professors. She said the process involves “a number of faculty panels” and could take as long as a year, but she doesn’t expect the professors would continue to be paid that entire time.
-Besides appointing new leadership for the Office of Diversity & Equity, Toro said she plans to explore a new model for investigating sexual harassment, bullying and misconduct on campus, and to adopt an institution-wide reporting, monitoring and tracking system to collect and disseminate data, as well as taking other steps.
+module jinvertertb;
+ reg a;
+ wire y;
+
+ //Design Instance
+ jinverter jinv(y,a);
+
+ initial
+ begin
+ $display ("RESULT\ta\ty");
+
+ a = 1; # 100; // Another value
+ if ( y == 0 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 0; # 100; // Initial value is set
+ if ( y == 1 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 1; # 50; // Another value
+ if ( y == 0 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ a = 0; # 100; // Initial value is set
+ if ( y == 1 ) // Test for inversion
+ $display (" PASS \t%d\t%d",a,y);
+ else
+ $display (" FAIL \t%d\t%d",a,y);
+
+ end
+
+ //enabling the wave dump
+ initial begin
+ $dumpfile("dump.vcd"); $dumpvars;
+ end
+endmodule
+
+
+module jFIFOTb;
+ wire [7:0] DATAOUT;
+ wire full, empty;
+ reg clock, reset, wn, rn;
+ reg [7:0] DATAIN;
+
+ jFIFO jfifo(DATAOUT, full, empty, clock, reset, wn, rn, DATAIN);
+
+
+ //enabling the wave dump
+ initial begin
+ $dumpfile("dump.vcd"); $dumpvars;
+ end
+
+ initial
+ begin
+ clock = 0; DATAIN = 8'd0;
+ reset = 1; clock = 1; #5 ; clock = 0; #5;
+ reset = 0;
+
+ $display("Start testing");
+
+ // First write some data into the queue
+ wn = 1; rn = 0;
+ DATAIN = 8'd100;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd150;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd200;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd40;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd70;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd65;
+ clock = 1; #5 ; clock = 0; #5;
+ DATAIN = 8'd15;
+ clock = 1; #5 ; clock = 0; #5;
+
+ // Now start reading and checking the values
+ wn = 0; rn = 1;
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd100 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd150 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd200 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd40 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd70 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd65 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( DATAOUT === 8'd15 )
+ $display("PASS %p ", DATAOUT);
+ else
+ $display("FAIL %p ", DATAOUT);
+
+ clock = 1; #5 ; clock = 0; #5;
+ if ( empty === 1 )
+ $display("PASS %p ", empty);
+ else
+ $display("FAIL %p ", empty);
+ end
+
+endmodule
+
+
+To understand this example, you should have the knowledge of the following Java programming topics:
+
+ Java for Loop
+ Java while and do...while Loop
+
+The factorial of a positive number n is given by:
+
+factorial of n (n!) = 1 * 2 * 3 * 4 * ... * n
+
+Example 1: Find Factorial of a number using for loop
+
+public class Factorial {
+
+ public static void main(String[] args) {
+
+ int num = 10;
+ long factorial = 1;
+ for(int i = 1; i <= num; ++i)
+ {
+ // factorial = factorial * i;
+ factorial *= i;
+ }
+ System.out.printf("Factorial of %d = %d", num, factorial);
+ }
+}
-Toro noted that the most recent chief diversity officer, Rosa Rodriguez, left her post on Friday for “personnel reasons” that Toro said she could not discuss. She did say that Rodriguez would be going to a new position at Capital Community College “for some time.”
+Output
-“To those who bravely shared their stories with out investigators, I am immensely grateful,” Toro said. “This has been a painful process for all of those involved. I am resolved to take the actions necessary to ensure our campus is a safe environment for all and to restore faith and pride in Connecticut’s oldest public institution of higher education.”
+Factorial of 10 = 3628800
-Toro said she realized it may be a “sad day for the survivors, but at the same time I think it’s the beginning of a process that will help them heal and I think that will be positive at the end of the day.”
+In this program, we've used for loop to loop through all numbers between 1 and the given number num (10), and the product of each number till num is stored in a variable factorial.
-Mark Ojakian, president of the Connecticut State Colleges and Universities, said he applauds Toro “for taking prompt and decisive action to make CCSU - and the theatre department in particular - a better, more welcoming learning environment.”
+We've used long instead of int to store large results of factorial. However, it's still not big enough to store the value of bigger numbers (say 100).
-He said the reports identify important steps needed to ensure that “all sexual misconduct complaints are received with the utmost seriousness, thoroughly investigated, and acted upon accordingly. I am beyond confident in the President’s ability to oversee and implement the necessary cultural and policy changes in a thoughtful and transparent manner.”
+For results that cannot be stored in a long variable, we use BigInteger variable declared in java.math library.
+Example 2: Find Factorial of a number using BigInteger
-A troubled theater department
+import java.math.BigInteger;
-The investigators paint a picture of a theater department that is rife with tension and conflict among professors, while also quite informal. Those interviewed said that students and some faculty frequently socialize at parties or other gatherings where alcohol is consumed.
+public class Factorial {
-In addition, those interviewed raised concerns with investigators about the “propriety” of some theater class exercises, such as massage circles.
+ public static void main(String[] args) {
-“It appears as though the informality of the department has led to a climate in which personal space and boundaries are not respected,” the report said.
+ int num = 30;
+ BigInteger factorial = BigInteger.ONE;
+ for(int i = 1; i <= num; ++i)
+ {
+ // factorial = factorial * i;
+ factorial = factorial.multiply(BigInteger.valueOf(i));
+ }
+ System.out.printf("Factorial of %d = %d", num, factorial);
+ }
+}
-Faculty, administrators and students reported that there were ” rumors” about relationships between professors and students for years, which they believe have not been properly addressed, the report said.
+Output
-The report includes concerns that Rodriguez, the most recent chief diversity officer, as well as her predecessors, are “not welcoming or friendly, and in some cases intimidating and/or lacking follow through.”
+Factorial of 30 = 265252859812191058636308480000000
-The investigators said the office is not fulfilling “the crucial function of receiving, investigating and addressing complaints.”
+Here, instead of long, we use BigInteger variable factorial.
-In addition, the investigators found that Human Resources officials failed to interview complainants or witnesses about alleged misconduct involving theater faculty members.
+Since, * cannot be used with BigInteger, we instead use multiply() for the product. Also, num should be casted to BigInteger for multiplication.
-Rodriguez’s office referred questions about the report to the university’s public relations office.
+Likewise, we can also use a while loop to solve this problem.
+Example 3: Find Factorial of a number using while loop
-In at least one case, the report said, a former human resources officer named Anne Alling contacted a relevant potential witness and then later sent the same individual an email indicating that an interview was no longer required, even though the concern still existed and the faculty member remained employed at the university. In two other cases, another former Human Resources officer, Lou Pisano, failed to interview a relevant student witness before making a determination on the matter.
+public class Factorial {
-Had the human resource office conducted further inquiry in those cases, the report said, “the outcome may have been substantially different and more significant prior discipline issued up to and including termination of the professor’s employment.”
+ public static void main(String[] args) {
-The report also said that it is troubling that other high level administrators did not take action to prevent a recurrence. The report says that a former dean and provost, Susan Pease, in setting goals for the theater department in 2014, said that faculty needed to “shape up,” adding that “shape up means: 1) they have to stop sleeping with students 2) they have to stop yelling at students and each other,” and several other goals including putting “on shows that people want to see.”
+ int num = 5, i = 1;
+ long factorial = 1;
+ while(i <= num)
+ {
+ factorial *= i;
+ i++;
+ }
+ System.out.printf("Factorial of %d = %d", num, factorial);
+ }
+}
-“Despite the fact that she was aware of these complaints, she did not effectively address them,” the report said.
+Output
-Pease, who retired last February, said in an email Tuesday that the “goals” were sent “in an informal email to the acting chair of Theater I had recommended for appointment and represented my frustration with the department.”
+Factorial of 5 = 120
-Students described Perlstein as ‘creepy’
+In the above program, unlike a for loop, we have to increment the value of i inside the body of the loop.
-The report says nearly all of the students interviewed used the word “creepy” to describe Perlstein and reported that he routinely conducted warm-up exercises, improvisations and visualizations in class in which he sometimes asked students to imagine themselves naked or act out words representing various sexual activities such as “sex” and “orgasm.”
+Though both programs are technically correct, it is better to use for loop in this case. It's because the number of iteration (upto num) is known.
-Several students said they told investigators that at times they caught Perlstein looking at them during these exercises in ways that made them feel uncomfortable.
+Visit this page to learn to find factorial of a number using recursion.
-Current and former students also told investigators that Perlstein would make comments about their weight, body parts and sexuality. He told one student she was not “sexual enough” to play a certain role. He also told that student, “You walk into a room and your tits are like bam.”
-Some told investigators that Perlstein seemed to deliberately choose plays that included sexual themes or nudity.
-The report tells of two instances in which Perlstein was accused of kissing students. The first was in the 1990s, when the student alleged that Perlstein approached her from behind and tried to kiss her on the lips while she stood outside the Black Box Theater at CCSU.
+Java Program to Check Whether a Number can be Expressed as Sum of Two Prime Numbers
-The student managed to turn her head so the kiss landed on her cheek, according to the report, but Perlstein allegedly whispered to her that she should “not attempt to pull away when [he is] trying to kiss her.”
+To understand this example, you should have the knowledge of the following Java programming topics:
-A few weeks later the student confronted Perlstein and told him that he had made her uncomfortable and he should never attempt to do that again. The student told investigators that Perlstein was most concerned during that exchange about whether she had reported the incident to the university.
+ Java Methods
+ Java for Loop
+ Java if...else Statement
-The report said that during his interview with the investigators, Perlstein denied engaging in the alleged conduct or said it was the result of a “misunderstanding.” In the case involving the student outside the Black Box theater, the report said Perlstein claimed “he was merely trying to congratulate her after she allegedly told him that she was ‘getting married.'”
+Example: Represent a number as Sum of Two Prime Numbers
-The investigators said this is not “credible given the fact that the student was already married when she enrolled in the university a few years earlier.”
+public class Main {
-Perlstein also disputed the account of a student in which he was found by CCSU to have engaged in “inappropriate behavior/sexual harassment.” The student accused him of kissing her, hugging her and touching her buttocks. Perlstein said he had been having an “emotional” not “sexual” conversation with her and kissed her on the cheek, but he denied touching her buttocks.
+ public static void main(String[] args) {
+ int number = 34;
+ boolean flag = false;
+ for (int i = 2; i <= number / 2; ++i) {
-According to Perlstein, the CCSU staff member at the time told him that “if we call it sexual harassment, it will go away.” Perlstein claimed that he was told that otherwise, there was a “high likelihood” that the matter would be pursued with authorities by the student’s “crazy father,” the report said. Perlstein therefore accepted the findings of the CCSU report because he thought it would end the inquiry, according to the Shipman & Goodwin report.
+ // condition for i to be a prime number
+ if (checkPrime(i)) {
-Anna Kelly, who was the student in this incident and is now in her mid-30s living in Hartford, said she is encouraged to know the report will be “a catalyst to move the school forward — that it’s going to bring about actual change and actual consequences for these people who have gone unchecked and unpunished for a long time.”
+ // condition for n-i to be a prime number
+ if (checkPrime(number - i)) {
-In his interview, the report said, Perlstein admitted that he engaged in a consensual relationship with a student he was teaching and advising in 2013, but claimed it was limited to a one or two weeks while he was advising her.
+ // n = primeNumber1 + primeNumber2
+ System.out.printf("%d = %d + %d\n", number, i, number - i);
+ flag = true;
+ }
-But the report said that “substantial electronic communications” between the professor and the student demonstrate that their inappropriate relationship lasted for “an extended period of time” from 2013 until the summer of 2014 when the student graduated, with some breaks along the way.
+ }
+ }
-In August 2013, Perlstein was disciplined by the university for having a relationship with a student he was teaching and advising but the report says it is clear that both before and after that, Perlstein continued to advise, assist and direct activities involving the student.
+ if (!flag)
+ System.out.println(number + " cannot be expressed as the sum of two prime numbers.");
+ }
-Perlstein said the relationship with the student, whether before or after she graduated, was consensual and not coercive, the report said. But the student told the investigators that she did not believe the relationship was “fully consensual on her part.”
+ // Function to check prime number
+ static boolean checkPrime(int num) {
+ boolean isPrime = true;
-Because Perlstein was her adviser for her honors thesis, the student told investigators she believed she needed his assistance to successfully complete her project and graduate.
+ for (int i = 2; i <= num / 2; ++i) {
+ if (num % i == 0) {
+ isPrime = false;
+ break;
+ }
+ }
-“She claims that she felt as though she had no choice but to capitulate to his demands,” the report said.
+ return isPrime;
+ }
+}
-Evidence of their ongoing relationship can be found in multiple texts included in the report including one from early 2014, the report said, in which Perlstein says, “Sorry about attacking your butt … it was aggressive and wrong …have a swell day. Love yoi [sic] ”
+Run Code
-The texts included in the report depict a controlling and manipulative relationship in which Perlstein tried to keep the relationship going while the student tried to break it off, but feared that doing so might harm her academic and theater career.
+Output
-“The extensive communications demonstrate that he engaged in a long-term sexual relationship significantly beyond what any reasonable person would view as appropriate between a professor and student,” the report said. The report said further that the text messages demonstrate that Perlstein was aware his actions were wrong.
+34 = 3 + 31
+34 = 5 + 29
+34 = 11 + 23
+34 = 17 + 17
-Ashley Malloy, who has identified herself as the young woman who had the long relationship with Perlstein and who is now in a graduate school theater program in San Francisco said the reports offers “some relief that the truth is finally coming out but the fact that it’s this long overdue definitely doesn’t take the sting out of what has happened.”
+In the above example, we have created the checkPrime() method to find whether a number is prime or not. The method returns true if the passed number is prime.
-“To just read in no uncertain terms the extent to which the administration was aware of what was going on,” Malloy said, “is so disheartening and destroyed whatever little bit of faith I had left in the institution.”
+Here, we have a number 34. The program tries to check if 34 can be represented as the sum of two prime numbers.
+
+Working of Program
+
+ First, we run a for loop from i = 2 to number / 2.
+ Inside the for loop, we used two if statements. The first statement checks if i is prime or not.
+
+ If true, the second if statement checks if number - i is prime or not. This is because the sum of i and number - i is equal to number.
+ If the second statement is also true, then we can say the number 34 is a valid sum of two prime numbers.
-But she said she does applaud Toro’s actions.
-Delventhal admits kissing at least five students
-During his interview, Delventhal admitted that he probably kissed at least five students on the neck and forehead.
-Delventhal told investigator that this was a way of expressing his endearment for a student and explained that this was the manner in which he was kissed by female members of his family. He said he did not see it as inappropriate or sexual in nature.
+// Java Program to Check if Given Integer is Odd or Even
+// Using Brute Forcew Approach
-However, at least one student told investigator that his kisses made her uncomfortable.
+// Importing required classes
+import java.io.*;
+import java.util.Scanner;
-The investigators found that Delventhal “knew or should have known” that such contact was inappropriate and not in compliance with university policies.”
-Q:
+// Main class
+class GFG {
-Is a virtual function of a template class implicitly instantiated?
+ // Main Driver Method
+ public static void main(String[] args)
+ {
+ // Declaring and initializing integer variable
+ int num = 10;
-Consider the following code. Is it guaranteed that Derived::foo() will be instantiated? foo() is virtual and is called by a non-virtual function of the base class.
-#include
+ // Checking if number is even or odd number
+ // via remainder
+ if (num % 2 == 0) {
-class Base
-{
-public:
- void bar() { foo(); }
-private:
- virtual void foo() = 0;
-};
+ // If remainder is zero then this number is even
+ System.out.println("Entered Number is Even");
+ }
-template class Derived: public Base
-{
-public:
- Derived(T t_) : t(t_) {}
-private:
- void foo() override { std::cout << t; }
- T t;
-};
+ else {
-Derived make_obj()
-{
- return Derived(7);
+ // If remainder is not zero then this number is
+ // odd
+ System.out.println("Entered Number is Odd");
+ }
+ }
}
-A:
-
-Standard section 14.7.1/11 says
-It is unspecified whether or not an implementation implicitly instantiates a virtual member function of a class template if the virtual member function would not otherwise be instantiated.
-However, for a typical vtable implementation, instantiating any constructor of the class requires a vtable for the class to exist, which must contain a pointer to the specialization's virtual function definition. So in practice the virtual function will probably be instantiated.
+// Java Program to find even sum of
+// fibonacci Series Till number N
+import java.io.*;
-Q:
+class geeksforgeeks {
-Show that $S_5$ does not have a quotient group isomorphic to $S_4$
+ // Computing the value of first fibonacci series
+ // and storing the sum of even indexed numbers
+ static int Fib_Even_Sum(int N)
+ {
+ if (N <= 0)
+ return 0;
-Show that $S_5$ does not have a quotient group isomorphic to $S_4$.
+ int fib[] = new int[2 * N + 1];
+ fib[0] = 0;
+ fib[1] = 1;
-If we to assume that $H$ is such a group, than $H$ must be normal in $S_5$ and $|H|=|S_5|/|S_4|=5$. So $H$ must be isomorphic to $\mathbb{Z}/5\Bbb Z$.
-That's as far as my logic goes. I couldn't arrive at a contradiction.
-Any ideas?
+ // Initializing the sum
+ int s = 0;
-A:
+ // Adding remaining numbers
+ for (int j = 2; j <= 2 * N; j++) {
+ fib[j] = fib[j - 1] + fib[j - 2];
-The possible candidates for such an $H$ are the subgroups of $S_5$ that are cyclic of order 5. All elements of $S_5$ of order 5 are given by $5$-cycles. However, the subgroup generated by a 5-cycle is not normal, so no $H$ can exist, as desired.
+ // Only considering even indexes
+ if (j % 2 == 0)
+ s += fib[j];
+ }
-A:
+ return s;
+ }
-The kernel of a surjective homomorphism from $S_5$ to $S_4$ would have order $|S_5|/|S_4|=5.$ This is impossible because: $S_5$ has $1+4!=25$ elements of order $1$ or $5$; the image of each of those $25$ elements must have order $1$ or $5$ in $S_4$; but $S_4$ has no elements of order $5,$ so those $25$ elements must all belong to the kernel of the homomorphism.
+ // The Driver code
+ public static void main(String[] args)
+ {
+ int N = 11;
+ // Prints the sum of even-indexed numbers
+ System.out.println(
+ "Even sum of fibonacci series till number " + N
+ + " is: " + +Fib_Even_Sum(N));
+ }
+}
-Forum of Private Business
-The Forum of Private Business or The Forum (The FPB) is a UK-based membership organisation which campaigns for the interests of small and medium-sized businesses. A member-funded organisation, it offers practical business advice and help, as well as offering a range of products and services to help its members save money. The Forum was established in 1977, is a non-party political organisation and represents over 25,000 UK businesses.
-Background
-The Forum (the FPB) was founded by Stan Mendham in 1977. Previously, Mendham had run an engineering business but was becoming increasingly concerned by the lack of understanding of smaller businesses in the economy and mounting red tape. He studied member-based organisations for smaller businesses in America and Canada, and decided to create a British equivalent.
+ It can be clearly seen that the required sum can be obtained thus:
+ 2 ( F2 + F4 + F6 +………+ F2n ) = (F1 + F2 + F3 + F4 +………+ F2n) – (F1 – F2 + F3 – F4 +………+ F2n)
+ Now the first term can be obtained if we put 2n instead of n in the formula given here.
+ Thus F1 + F2 + F3 + F4 +………+ F2n = F2n+2 – 1.
-The language of a foreign text can often be identified by looking up characters specific to that language.
+ The second term can also be found if we put 2n instead of n in the formula given here
- ABCDEFGHIJKLMNOPQRSTUVWXYZ (Latin alphabet)
- and no other – English, Indonesian, Latin, Malay, Swahili, Zulu
- àäèéëïijöü – Dutch (Except for the ligature ij, these letters are very rare in Dutch. Even fairly long Dutch texts often have no diacritics.)
- áêéèëïíîôóúû Afrikaans
- êôúû – West Frisian
- ÆØÅæøå – Danish, Norwegian
- single diacritics, mostly umlauts
- ÄÖäö – Finnish (BCDFGQWXZÅbcfgqwxzå are found only in names and loanwords, occasionally also ŠšŽž)
- ÅÄÖåäö – Swedish (occasionally é)
- ÄÖÕÜäöõü – Estonian (BCDFGQWXYZcfqwxyz are found only in names and loanwords, occasionally also ŠšŽž)
- ÄÖÜẞäöüß – German
- Circumflexes
- ÇÊÎŞÛçêîşû – Kurdish
- ĂÂÎȘȚăâîșț – Romanian
- ÂÊÎÔÛŴŶÁÉÍÏâêîôûŵŷáéíï – Welsh; (ÓÚẂÝÀÈÌÒÙẀỲÄËÖÜẄŸóúẃýàèìòùẁỳäëöüẅÿ used also but much less commonly)
- ĈĜĤĴŜŬĉ��ĥĵŝŭ – Esperanto
- Three or more types of diacritics
- ÇĞİÖŞÜçğıöşü – Turkish
- ÁÐÉÍÓÚÝÞÆÖáðéíóúýþæö – Icelandic
- ÁÐÍÓÚÝÆØáðíóúýæø – Faroese
- ÁÉÍÓÖŐÚÜŰáéíóöőúüű – Hungarian
- ÀÇÉÈÍÓÒÚÜÏàçéèíóòúüï· – Catalan
- ÀÂÆÇÉÈÊËÎÏÔŒÙÛÜŸàâæçéèêëîïôœùûüÿ – French; (Ÿ and ÿ are found only in certain proper names)
- ÁÀÇÉÈÍÓÒÚËÜÏáàçéèíóòúëüï (· only in Gascon dialect) – Occitan
- ÁÉÍÓÚÂÊÔÀãõçáéíóúâêôà (ü Brazilian and k, w and y not in native words) – Portuguese
- ÁÉÍÑÓÚÜáéíñóúü ¡¿ – Spanish
- ÀÉÈÌÒÙàéèìòù – Italian
- ÁÉÍÓÚÝÃẼĨÕŨỸÑG̃áéíóúýãẽĩõũỹñg̃ - Guarani (the only language to use g̃)
- ÁĄĄ́ÉĘĘ́ÍĮĮ́ŁŃ áąą́éęę́íįį́łń (FQRVfqrv not in native words) – Southern Athabaskan languages
- ’ÓǪǪ́ āą̄ēę̄īį̄óōǫǫ́ǭúū – Western Apache
- 'ÓǪǪ́ óǫǫ́ – Navajo
- ’ÚŲŲ́ úųų́ – Chiricahua/Mescalero
- ąłńóż Lechitic languages
- ćęłńóśźż Polish
- ćśůź Silesian
- ãéëòôù Kashubian
- A, Ą, Ã, B, C, D, E, É, Ë, F, G, H, I, J, K, L, Ł, M, N, Ń, O, Ò, Ó, Ô, P, R, S, T, U, Ù, W, Y, Z, Ż – Kashubian
- ČŠŽ
- and no other – Slovene
- ĆĐ – Bosnian, Croatian, Serbian Latin
- ÁĎÉĚÍŇÓŘŤÚŮÝáďéěíňóřťúůý – Czech
- ÁÄĎÉÍĽĹŇÓÔŔŤÚÝáäďéíľĺňóôŕťúý – Slovak
- ĀĒĢĪĶĻŅŌŖŪāēģīķļņōŗū – Latvian; (ŌŖ and ōŗ no longer used in most modern day Latvian)
- ĄĘĖĮŲŪąęėįųū – Lithuanian
- ĐÀẢÃÁẠĂẰẲẴẮẶÂẦẨẪẤẬÈẺẼÉẸÊỀỂỄẾỆÌỈĨÍỊÒỎÕÓỌÔỒỔỖỐỘƠỜỞỠỚỢÙỦŨÚỤƯỪỬỮỨỰỲỶỸÝỴ đàảãáạăằẳẵắặâầẩẫấậèẻẽéẹêềểễếệìỉĩíịòỏõóọồổỗốơờởỡớợùủũúụưừửữứựỳỷỹýỵ – Vietnamese
- ꞗĕŏŭo᷄ơ᷄u᷄ – Middle Vietnamese
- ā ē ī ō ū – May be seen in some Japanese texts in Rōmaji or transcriptions (see below) or Hawaiian and Māori texts.
- é – Sundanese
- ñ - Basque
- أ ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه ؤ و ئ ى ي ء Arabic script
- Arabic, Malay (Jawi), Kurdish (Soranî), Panjabi / Punjabi, Pashto, Sindhi, Urdu, others.
- پ چ ژ گ – Persian (Farsi)
- Brahmic family of scripts
- Bengali script
- অ আ কা কি কী উ কু ঊ কূ ঋ কৃ এ কে ঐ কৈ ও কো ঔ কৌ ক্ কত্ কং কঃ কঁ ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য র ৰ ল ৱ শ ষ স হ য় ড় ঢ় ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯
- used to write Bengali and Assamese.
- Devanāgarī
- अ आ इ ई उ ऊ ऋ ॠ ऌ ॡ ऍ ऎ ए ऐ ऑ ऒ ओ ओ क ख ग घ ङ च छ ज झ ञ ट ठ ड ढ ण त थ द ध न प फ ब भ म य र ल ळ व श ष स ह ० १ २ ३ ४ ५ ६ ७ ८ ९ प् पँ पं पः प़ पऽ
- used to write, either along with other scripts or exclusively, several Indian languages including Sanskrit, Hindi, Maithili, Magahi Marathi, Kashmiri, Sindhi, Bhili, Konkani, Bhojpuri and Nepali from Nepal.
- Gurmukhi
- ਅਆਇਈਉਊਏਐਓਔਕਖਗਘਙਚਛਜਝਞਟਠਡਢਣਤਥਦਧਨਪਫਬਭਮਯਰਲਲ਼ਵਸ਼ਸਹ
- primarily used to write Punjabi as well as Braj Bhasha, Khariboli (and other Hindustani dialects), Sanskrit and Sindhi.
- Gujarati script
- અ આ ઇ ઈ ઉ ઊ ઋ ઌ ઍ એ ઐ ઑ ઓ ઔ ક ખ ગ ઘ ઙ ચ છ જ ઝ ઞ ટ ઠ ડ ઢ ણ ત થ દ ધ ન પ ફ બ ભ મ ય ર લ ળ વ શ ષ સ હ ૠ ૡૢૣ
- used to write Gujarati and Kachchi
- Tibetan script
- ཀ ཁ ག ང ཅ ཆ ཇ ཉ ཏ ཐ ད ན པ ཕ བ མ ཙ ཚ ཛ ཝ ཞ ཟ འ ཡ ར ལ ཤ ས ཧ ཨ
- used to write Standard Tibetan, Dzongkha (Bhutanese), and Sikkimese
- АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШ (Cyrillic alphabet)
- ЙЩЬЮЯ
- Ъ – Bulgarian
- ЁЫЭ
- Ў, no Щ, І instead of И (Ґ in some variants) – Belarusian
- rarely Ъ – Russian
- ҐЄІЇ – Ukrainian
- ЉЊЏ, Ј instead of Й (Vuk Karadžić's reform)
- ЃЌЅ – Macedonian
- ЋЂ – Serbian
- ЄꙂꙀЗІЇꙈОуꙊѠЩЪꙐЬѢЮꙖѤѦѨѪѬѮѰѲѴҀ – Old Church Slavonic, Church Slavonic
- Ӂ – Romanian in Transnistria (elsewhere in Latin)
- ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ αβγδεζηθικλμνξοπρσςτυφχψω (Greek Alphabet) – Greek
- אבגדהוזחטיכלמנסעפצקרשת (Hebrew alphabet)
- and maybe some odd dots and lines above, below, or inside characters – Hebrew
- פֿ; dots/lines below letters appearing only with א,י, and ו – Yiddish
- no dots or lines around the letters, and more than a few words end with א (i.e., they have it at the leftmost position) – Aramaic
- Ladino
- 漢字文化圈 – Some East Asian Languages
- and no other – Chinese
- with あいうえおの Hiragana and/or アイウエオノ Katakana – Japanese
- 위키백과에 (note commonplace ellipses and circles) Korean
- ㄅㄆㄇㄈㄉㄊㄋㄌㄍㄎㄏ etc. -- ㄓㄨˋㄧㄣㄈㄨˊㄏㄠˋ (Bopomofo)
- ㄪㄫㄬ -- not Mandarin
- កខគឃងចឆជឈញដឋឌឍណតថទធនបផពភមសហយរលឡអវអ្កអ្ខអ្គអ្ឃអ្ងអ្ចអ្ឆអ្ឈអ្ញអ្ឌអ្ឋអ្ឌអ្ឃអ្ណអ្តអ្ថអ្ទអ្ធអ្នអ្បអ្ផអ្ពអ្ភអ្មអ្សអ្ហអ្យអ្រអ្យអ្លអ្អអ្វ អក្សរខ្មែរ (Khmer alphabet) - Khmer
- Ա Բ Գ Դ Ե Զ Է Ը Թ Ժ Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ Մ Յ Ն Շ Ո Չ Պ Ջ Ռ Ս Վ Տ Ր Ց Ւ Փ Ք Օ Ֆ (Armenian alphabet) – Armenian
- ა ბ გდ ევ ზ ჱ თ ი კ ლ მ ნ ჲ ო პ ჟ რ ს ტ ჳ უ ფ ქ ღ ყ შ ჩ ც ძ წ ჭ ხ ჴ ჯ ჰ ჵ ჶ ჷ ჸ (Georgian alphabet) – Georgian
- กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะา฿เแโใไๅๆ๏๐๑๒๓๔๕๖๗๘๙๚๛ (Thai script) - Thai
- AEIOUHKLMNPW' Hawaiian alphabet - Hawaiian
- ⴰⴱⴲⴳⴴⴵⴶⴷⴸⴹⴺⴻⴼⴽⴾⴿⵀⵁⵂⵃⵄⵅⵆⵇⵈⵉⵊⵋⵌⵍⵎⵐⵑⵒⵓⵔⵕⵖⵗⵘⵙⵚⵛⵜⵝⵞⵠⵡⵢⵣⵤⵥⵦⵧ Tifinagh, a script used for Tamazight (Berber)
+ Thus, F1 – F2 + F3 – F4 +………- F2n = 1 + (-1)2n+1F2n-1 = 1 – F2n-1.
-Latin alphabet (possibly extended)
-Romance languages
+ So, 2 ( F2 + F4 + F6 +………+ F2n)
+ = F2n+2 – 1 – 1 + F2n-1
+ = F2n+2 + F2n-1 – 2
+ = F2n + F2n+1 + F2n+1 – F2n – 2
+ = 2 ( F2n+1 -1)
+ Hence, ( F2 + F4 + F6 +………+ F2n) = F2n+1 -1 .
-Lots of Latin roots.
-French (Français)
- Accented letters: â ç è é ê î ô û, rarely ë ï ; ù only in the word où, à only at the ends of a few words (including à). Never á í ì ó ò ú.
- Angle quotation marks: « » (though "curly-Q" quotation marks are also used); dialogue traditionally indicated by means of dashes.
- Common short words: la, le, les, un, une, des, de, du, à, au, et, ou, où, sur, il, elle, ils, se, je, vous, que, qui, y, en, si, ne, est, sont, a, ont.
- Many apostrophised contractions for common pronouns and particles, i.e. words l' or d', less often c', j', m', n', s', t', or rarely z' — only before a word starting by a vowel or, in some cases, an h.
- Common digraphs and trigraphs:
- Vowels digraphs: au, ai, ei, ou. Word-final -ez.
- Vowels digraphs (nasals): an, en, in, on, rarely un. For all of these, the n become m before b, p or m (e.g. embouchure, never *enbouchure).
- Vowel trigraphs: eau, ein, ain, oin.
- Consonant digraphs: ch, gu-. Rarely sh. Semi-consonant -ill-.
- Letters w and k, are rare and used only in loanwords, most often from Germanic languages (e.g whisky).
- Ligatures œ and æ are conventional but are rarely used (a few words are well known, e.g. œil, œuf(s), bœuf(s), most other are scientific/technical and borrowed from Latin).
- Words ending in -aux, -eux, or -oux.
-Spanish (Español)
+// Java Program to find even indexed
+// Fibonacci Sum in O(Log n) time.
- Characters: ¿ ¡ (inverted question and exclamation marks), ñ
- All vowels (á, é, í, ó, ú) may take an acute accent
- The letter u can take a diaeresis (ü), but only after the letter g
- Some words frequently used: de, el, del, los, la(s), uno(s), una(s), y
- No apostrophised contractions
- No use of grave accent
- Letters k and w are rare and only used in loanwords (e.g. walkman)
- Word beginnings: ll- (check not Welsh or Catalan) double L (ll)
- Word endings: -o, -a, -ción, -miento, -dad
- Angle quotation marks: « » (though "curly-Q" quotation marks are also used); dialogue often indicated by means of dashes
+class GFG {
-Italian (Italiano)
+ static int MAX = 1000;
- Almost every native word ends in a vowel. Example exceptions include non, il, per, con, del.
- Common one-letter word: è.
- Common word: perché.
- Letter sequences: gli, gn, sci.
- Letters j, k, w, x and y are rare and used only in loanwords (e.g. whisky).
- Word endings: -o, -a, -zione, -mento, -tà, -aggio.
- Grave accent (e.g., on à) almost always occurs in the last letter of words.
- Double consonants (tt, zz, cc, ss, bb, pp, ll, etc.) are frequent.
+ // Create an array for memoization
+ static int f[] = new int[MAX];
-Catalan (Català)
+ // Returns n'th Fibonacci number
+ // using table f[]
+ static int fib(int n)
+ {
+ // Base cases
+ if (n == 0) {
+ return 0;
+ }
+ if (n == 1 || n == 2) {
+ return (f[n] = 1);
+ }
- Characters: à, è, é, í, ï, ò, ó, ú, ü, ç, ·
- Character combination tz (also common in Basque, however) and l·l
- Syllables and words ending in -aig, -eig, -oig, -uig, -aix, -eix, -oix, -uix
- Letter sequences: tx (also common in Basque, however) and tg
- Letter y is only used in the combination ny and loanwords
- Letters k and w are rare and only used in loanwords (e.g. walkman)
- Word endings: -o, -a, -es, -ció, -tat, -ment
- Word beginning: ll- (also common in Spanish and Welsh, however)
- Common words: això, amb, mateix, tots, que
+ // If fib(n) is already computed
+ if (f[n] == 1) {
+ return f[n];
+ }
-Romanian (Română)
+ int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2;
- Characters: ă â î ș ț
- Common words: și, de, la, a, ai, ale, alor, cu
- Word endings: -a, -ă, -u, -ul, -ului, -ție (or -țiune), -ment, -tate; names ending in -escu
- Double and triple i: copii, copiii
- Note that Romanian is sometimes written online with no diacritics, making it harder to identify. A cedilla is sometimes used on S (ş) and on T (ţ) instead of the correct diacritic, the comma (above).
+ // Applying above formula [Note value n&1 is 1
+ // if n is odd, else 0].
+ f[n] = (n % 2 == 1)
+ ? (fib(k) * fib(k)
+ + fib(k - 1) * fib(k - 1))
+ : (2 * fib(k - 1) + fib(k)) * fib(k);
-Portuguese (Português)
+ return f[n];
+ }
- Characters: ã, õ, â, ê, ô, á, é, í, ó, ú, à, ç
- Common one-letter words: a, à, e, é, o
- Common two-letter words: ao, as, às, da, de, do, em, os, ou, um
- Common three-letter words: aos, com, das, dos, ele, ela, mas, não, por, que, são, uma
- Common endings: -ção, -dade, -ismo, -mente
- Common digraphs: ch, nh, lh; examples: chave, galinha, baralho.
- The letters k, w and y are rare. They are found mostly in loanwords, e.g.: keynesianismo, walkie-talkie, nylon.
- Most singular words end in a vowel, l, m, r, or z.
- Plural words end in -s.
+ // Computes value of even-indexed Fibonacci Sum
+ static int calculateEvenSum(int n)
+ {
+ return (fib(2 * n + 1) - 1);
+ }
-Walloon (Walon)
+ // Driver program to test above function
+ public static void main(String[] args)
+ {
+ // Get n
+ int n = 11;
- Characters: å, é, è, ê, î, ô, û
- Common digraphs and trigraphs: ai, ae, én, -jh-, tch, oe, -nn-, -nnm-, xh, ou
- Common one-letter words: a, å, e, i, t', l', s', k'
- Common two-letter words: al, ås, li, el, vs, ki, si, pô, pa, po, ni, èn, dj'
- Common three-letter words: dji, nén, rén, bén, pol, mel
- Common endings: -aedje, -mint, -xhmint, -ès, -ou, -owe, -yî, -åcion
- Apostrophes are followed by a space (preferably non breaking one), eg: l' ome instead of l'ome.
+ // Find the alternating sum
+ System.out.println(
+ "Even indexed Fibonacci Sum upto " + n
+ + " terms: " + calculateEvenSum(n));
+ }
+}
-Galician (Galego)
+SCREEN 13
+z = 1 / 100
+FOR i = 0 TO 255
+ PALETTE i, INT(i / 4) + INT(i / 4) * 256 + INT(i / 4) * 65536
+NEXT
+DO
+ y = 1
+ dy = 0
+ ox = 0: oy = 1
+ FOR x = 1 TO 430
+ IF y > 0 THEN dy = dy - 1 / 4000
+ IF y < 0 THEN dy = dy + z
+ y = y + dy
+ a = POINT(x, 100 + y * 50)
+ a = a + 1
+ IF a > 255 THEN a = 255
+ PSET (x, 100 + y * 50), a
+ NEXT
+ z = z - 1 / 10000
+LOOP
+
+
+DIM bodyx(70)
+DIM bodyy(70)
+DIM bodyvx(70)
+DIM bodyvy(70)
+DIM obodyx(70)
+DIM obodyy(70)
- Similar to Portuguese; the indefinite article "unha" (fem. plural), the suffix -ción and a heavier usage of the letter "x" usually sign Galician.
- Definite articles o (masc. sing.), os (masc. plural), a (fem. sing.), as (fem. plural)
- Common diagraphs: nh (ningunha)
- The letters j, k, w and y are not in the alphabet, and appear only in loanwords
+RANDOMIZE TIMER
-Germanic languages
-English
+bodies = 30
+FOR i = 1 TO bodies
+ bodyx(i) = 620 * RND + 10
+ bodyy(i) = 400 * RND + 30
+ bodyvx(i) = RND - .5
+ bodyvy(i) = RND - .5
+NEXT
+
+
+SCREEN 12
- words: a, an, and, in, of, on, the, that, to, is, what, I (I is always capital when talking about oneself)
- letter sequences: th, ch, sh, ough, augh, qu
- word endings: -ing, -tion, -ed, -age, -s, -’s, -’ve, -n’t, -’d
- diacritics or accents only in loanwords (piñata)
+PRINT "...."
+WHILE INKEY$ = "": WEND
+CLS
+
+
+
+
+
+DO
+
+' apply gravity
+
+FOR i = 1 TO bodies
+ bodyvy(i) = bodyvy(i) + .001
+NEXT
+
+' adjust distances
+
+FOR i = 1 TO bodies
+ FOR j = 1 TO bodies
+ IF i <> j THEN
+ centx = (bodyx(i) + bodyx(j)) * .5
+ centy = (bodyy(i) + bodyy(j)) * .5
+
+ distx = (bodyx(i) - bodyx(j)) / 2
+ disty = (bodyy(i) - bodyy(j)) / 2
+ distf = SQR(distx * distx + disty * disty)
+
+ mx = distx / distf
+ my = disty / distf
+
+ bodyvx(i) = bodyvx(i) - mx * (distf - 50) / 100
+ bodyvy(i) = bodyvy(i) - my * (distf - 50) / 100
+ END IF
+ NEXT
+NEXT
+
+' collide with ground
+
+FOR i = 1 TO bodies
+ IF bodyy(i) + bodyvy(i) > 440 OR bodyy(i) + bodyvy(i) < 5 THEN
+ bodyvy(i) = -bodyvy(i) * 0!
+ bodyvx(i) = bodyvx(i) * 0!
+ END IF
+ IF bodyx(i) + bodyvx(i) > 625 OR bodyx(i) + bodyvx(i) < 15 THEN
+ bodyvx(i) = -bodyvx(i) * 0!
+ bodyvy(i) = bodyvy(i) * 0!
+ END IF
+NEXT
+
+' move bodies
+
+FOR i = 1 TO bodies
+ obodyx(i) = bodyx(i)
+ obodyy(i) = bodyy(i)
+ bodyx(i) = bodyx(i) + bodyvx(i)
+ bodyy(i) = bodyy(i) + bodyvy(i)
+NEXT
+
+' clear/draw
+
+q = (q + 1) MOD 16
+
+FOR i = 1 TO bodies
+ COLOR 0
+ CIRCLE (obodyx(i), obodyy(i)), 4
+ COLOR 15
+ CIRCLE (bodyx(i), bodyy(i)), 4
+ 'COLOR q
+ 'LINE (bodyx(i), bodyy(i))-(bodyx(i) + bodyvx(i) * 30, bodyy(i) + bodyvy(i) * 30)
+NEXT
+
+COLOR 2
+LINE (obodyx(1), obodyy(1))-(bodyx(1), bodyy(1))
+
+'FOR i = 1 TO bodies - 1
+' FOR j = i + 1 TO bodies
+' COLOR 0
+' LINE (obodyx(i), obodyy(i))-(obodyx(j), obodyy(j))
+' COLOR 2
+' LINE (bodyx(i), bodyy(i))-(bodyx(j), bodyy(j))
+' NEXT
+'NEXT
+
+LOOP
+
+
+
+;---------------------------------------------------------------------------
+; start
+;---------------------------------------------------------------------------
+
+start
+ desc
+ msg "It's a room."
+ objects
+ start/key
+ start/door
+
+start/key
+ id "key"
+ desc
+ msg "It's a key."
+ actions
+ use door
+ ifn start/door.flags.locked
+ msg "The door isn't locked."
+ if start/door.flags.locked
+ msg "The lock on the door goes 'click'."
+ set start/door.flags.locked false
+ examine
+ msg "It is shiny."
+
+start/door
+ id "door"
+ desc
+ msg "You see a door."
+ flags
+ locked true
+ open false
+ actions
+ open
+ if start/door.flags.locked
+ msg "It is locked."
+ ifn start/door.flags.locked
+ msg "The door opens."
+ close
+ ifn start/door.flags.open
+ msg "It is already closed."
+ if start/door.flags.open
+ msg "The door closes."
+ go
+ if start/door.flags.open
+ goto end
+ ifn start/door.flags.open
+ msg "The door is closed."
+ examine
+ msg "It looks just like a door."
+
+;---------------------------------------------------------------------------
+; end
+;---------------------------------------------------------------------------
-Dutch (Nederlands)
+end
+ desc
+ "Congratimafations! Another room."
+ objects
+ start/door
+
+
+
+
+macroScript ExportCamera category:"Cameras" toolTip:"Blech!" Icon:#("Cameras",2)
+(
+ filename = maxFileName
+ flen = findString filename ".max"
+ filename = substring filename 1 (flen-1)
+
+ sname = filename
+
+ filename = maxFilePath + filename + ".piper3d"
+ deletefile filename
+ out_file = createfile filename
+
+
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Piper 3D scene file\n" to:out_file
+ format ";\n" to:out_file
+ format "; Scene: % \n" sname to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_begin\n" sname to:out_file
+ format "\n" to:out_file
+
+ animend = animationRange.end as string
+ animend = substring animend 1 (findString animend "f"-1)
+ format " dc.w % ; no. frames\n" animend to:out_file
+ format " dc.w % ; no. objects\n" objects.count to:out_file
+
+ faces = 0
+ vertices = 0
+ for o in objects do (
+ if classOf o == Editable_Mesh then (
+ faces += o.numfaces
+ vertices += o.numverts
+ )
+ )
+
+ format " dc.w % ; no. vertices\n" vertices to:out_file
+ format " dc.w % ; no. faces\n" faces to:out_file
+ format "\n" to:out_file
+
+ format " dc.w 0 ; current frame\n" to:out_file
+ format "\n" to:out_file
+
+ format " dc.l %_vtx ; begin vertices\n" sname sname to:out_file
+ format " dc.l %_fcs ; begin fæces\n" sname sname to:out_file
+ format " dc.l %_mtx ; begin matrices\n" sname sname to:out_file
+ format " dc.l 0 ; begin vertex normals\n" to:out_file
+ format "\n" to:out_file
+
+ format " dc.w 0 ; init flag\n" to:out_file
+ format "\n" to:out_file
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Vertex groups\n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_vtx\n" sname to:out_file
+ format "\n" to:out_file
+
+ for i=1 to objects.count do (
+ format "; group %: %\n" (i-1) objects[i].name to:out_file
+ format "\n" to:out_file
+
+ if classOf objects[i] == Editable_Mesh then (
+ obimat = (inverse objects[i].transform)
+ themesh = snapshotAsMesh objects[i]
+ format " dc.w % ; no. vertices\n" themesh.numverts to:out_file
+ for j=1 to themesh.numverts do (
+ v = (getVert themesh j) * obimat
+ vxs = formatf v.x 6
+ vys = formatf v.y 6
+ vzs = formatf v.z 6
+ format " dc.s %,%,%\n" vxs vys vzs to:out_file
+ )
+ ) else (
+ format " dc.w 0 ; not a mesh\n" to:out_file
+ )
+
+ format "\n" to:out_file
+ )
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Fæces\n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_fcs\n" sname to:out_file
+ format "\n" to:out_file
+
+ voff = 0
+
+ for i=1 to objects.count do (
+ format "; group %: %\n" (i-1) objects[i].name to:out_file
+ format "\n" to:out_file
+
+ if classOf objects[i] == Editable_Mesh then (
+ themesh = snapshotAsMesh objects[i]
+ for j=1 to themesh.numfaces do (
+ f = getFace themesh j
+ format " dc.w %,%,%\n" (int (f.x-1+voff)) (int (f.y-1+voff)) (int (f.z-1+voff)) to:out_file
+
+ smat = objects[i].material
+ mattype = "0"
+
+ u1 = 0
+ v1 = 0
+ u2 = 0
+ v2 = 0
+ u3 = 0
+ v3 = 0
+
+ if smat == undefined then (
+ matname = "0"
+ ) else (
+ if getNumSubMtls smat == 0 then (
+ mat = smat
+ ) else (
+ matid = getFaceMatID themesh j
+ mat = smat.MaterialList[matid]
+ )
+ matname = (int mat.diffuse.r)*256*256 + (int mat.diffuse.g)*256 + (int mat.diffuse.b)
+ dmap = mat.diffuseMap
+ if dmap != undefined then (
+
+ mattype = "1"
+ matname = dmap.filename
+ fntokens = filterString matname "\\"
+ matname = fntokens[fntokens.count]
+ fntokens = filterString matname "."
+ matname = fntokens[1]
+
+ fntokens = filterString matname "-"
+ matname = ""
+ for k=1 to fntokens.count do (
+ matname = matname + fntokens[k]
+ if k < fntokens.count then matname=matname+"m"
+ )
+ matname = sname + "_" + matname + "+1024+14"
+
+ tverts = getTVFace theMesh j
+ u1 = (int (getTVert theMesh tverts[1] * 65535).x)
+ v1 = 65535 - (int (getTVert theMesh tverts[1] * 65535).y)
+ u2 = (int (getTVert theMesh tverts[2] * 65535).x)
+ v2 = 65536 - (int (getTVert theMesh tverts[2] * 65535).y)
+
+macroScript ExportCamera category:"Cameras" toolTip:"Blech!" Icon:#("Cameras",2)
+(
+ filename = maxFileName
+ flen = findString filename ".max"
+ filename = substring filename 1 (flen-1)
+
+ sname = filename
+
+ filename = maxFilePath + filename + ".piper3d"
+ deletefile filename
+ out_file = createfile filename
+
+
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Piper 3D scene file\n" to:out_file
+ format ";\n" to:out_file
+ format "; Scene: % \n" sname to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_begin\n" sname to:out_file
+ format "\n" to:out_file
+
+ animend = animationRange.end as string
+ animend = substring animend 1 (findString animend "f"-1)
+ format " dc.w % ; no. frames\n" animend to:out_file
+ format " dc.w % ; no. objects\n" objects.count to:out_file
+
+ faces = 0
+ vertices = 0
+ for o in objects do (
+ if classOf o == Editable_Mesh then (
+ faces += o.numfaces
+ vertices += o.numverts
+ )
+ )
+
+ format " dc.w % ; no. vertices\n" vertices to:out_file
+ format " dc.w % ; no. faces\n" faces to:out_file
+ format "\n" to:out_file
+
+ format " dc.w 0 ; current frame\n" to:out_file
+ format "\n" to:out_file
+
+ format " dc.l %_vtx ; begin vertices\n" sname sname to:out_file
+ format " dc.l %_fcs ; begin fæces\n" sname sname to:out_file
+ format " dc.l %_mtx ; begin matrices\n" sname sname to:out_file
+ format " dc.l 0 ; begin vertex normals\n" to:out_file
+ format "\n" to:out_file
+
+ format " dc.w 0 ; init flag\n" to:out_file
+ format "\n" to:out_file
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Vertex groups\n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_vtx\n" sname to:out_file
+ format "\n" to:out_file
+
+ for i=1 to objects.count do (
+ format "; group %: %\n" (i-1) objects[i].name to:out_file
+ format "\n" to:out_file
+
+ if classOf objects[i] == Editable_Mesh then (
+ obimat = (inverse objects[i].transform)
+ themesh = snapshotAsMesh objects[i]
+ format " dc.w % ; no. vertices\n" themesh.numverts to:out_file
+ for j=1 to themesh.numverts do (
+ v = (getVert themesh j) * obimat
+ vxs = formatf v.x 6
+ vys = formatf v.y 6
+ vzs = formatf v.z 6
+ format " dc.s %,%,%\n" vxs vys vzs to:out_file
+ )
+ ) else (
+ format " dc.w 0 ; not a mesh\n" to:out_file
+ )
+
+ format "\n" to:out_file
+ )
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; Fæces\n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_fcs\n" sname to:out_file
+ format "\n" to:out_file
+
+ voff = 0
+
+ for i=1 to objects.count do (
+ format "; group %: %\n" (i-1) objects[i].name to:out_file
+ format "\n" to:out_file
+
+ if classOf objects[i] == Editable_Mesh then (
+ themesh = snapshotAsMesh objects[i]
+ for j=1 to themesh.numfaces do (
+ f = getFace themesh j
+ format " dc.w %,%,%\n" (int (f.x-1+voff)) (int (f.y-1+voff)) (int (f.z-1+voff)) to:out_file
+
+ smat = objects[i].material
+ mattype = "0"
+
+ u1 = 0
+ v1 = 0
+ u2 = 0
+ v2 = 0
+ u3 = 0
+ v3 = 0
+
+ if smat == undefined then (
+ matname = "0"
+ ) else (
+ if getNumSubMtls smat == 0 then (
+ mat = smat
+ ) else (
+ matid = getFaceMatID themesh j
+ mat = smat.MaterialList[matid]
+ )
+ matname = (int mat.diffuse.r)*256*256 + (int mat.diffuse.g)*256 + (int mat.diffuse.b)
+ dmap = mat.diffuseMap
+ if dmap != undefined then (
+
+ mattype = "1"
+ matname = dmap.filename
+ fntokens = filterString matname "\\"
+ matname = fntokens[fntokens.count]
+ fntokens = filterString matname "."
+ matname = fntokens[1]
+
+ fntokens = filterString matname "-"
+ matname = ""
+ for k=1 to fntokens.count do (
+ matname = matname + fntokens[k]
+ if k < fntokens.count then matname=matname+"m"
+ )
+ matname = sname + "_" + matname + "+1024+14"
+
+ tverts = getTVFace theMesh j
+ u1 = (int (getTVert theMesh tverts[1] * 65535).x)
+ v1 = 65535 - (int (getTVert theMesh tverts[1] * 65535).y)
+ u2 = (int (getTVert theMesh tverts[2] * 65535).x)
+ v2 = 65536 - (int (getTVert theMesh tverts[2] * 65535).y)
+ u3 = (int (getTVert theMesh tverts[3] * 65535).x)
+ v3 = 65536 - (int (getTVert theMesh tverts[3] * 65535).y)
+
+ if u1 > 65535 then u1 = 65535
+ if v1 > 65535 then v1 = 65535
+ if u2 > 65535 then u2 = 65535
+ if v2 > 65535 then v2 = 65535
+ if u3 > 65535 then u3 = 65535
+ if v3 > 65535 then v3 = 65535
+
+ /*
+ if u1 < 0 then u1 = 0
+ if v1 < 0 then v1 = 0
+ if u2 < 0 then u2 = 0
+ if v2 < 0 then v2 = 0
+ if u3 < 0 then u3 = 0
+ if v3 < 0 then v3 = 0
+ */
+
+ if mat.opacityMap != undefined then (
+ mattype = "2"
+ )
+ )
+ )
+
+ format " dc.w %\n" mattype to:out_file
+ format " dc.l %\n" matname to:out_file
+ format " dc.w %,%,%,%,%,%\n" u1 v1 u2 v2 u3 v3 to:out_file
+
+ )
+ format "\n" to:out_file
+
+ voff += themesh.numverts
+ )
+ )
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; \n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_mtx\n" sname to:out_file
+ format "\n" to:out_file
+
+ for i = animationRange.start to animationRange.end do (
+
+ sliderTime=i
+
+ format "; index %\n" i to:out_file
+ format "\n" to:out_file
+
+ for j = 1 to objects.count do (
+
+ o=objects[j]
+
+ vpm=getViewTM()
+ tm=o.transform*vpm
+ tm1=tm.row1
+ tm2=tm.row2
+ tm3=tm.row3
+ tm4=tm.row4
+ tm11=formatf tm1.x 6
+ tm12=formatf tm1.y 6
+ tm13=formatf tm1.z 6
+ tm21=formatf tm2.x 6
+ tm22=formatf tm2.y 6
+ tm23=formatf tm2.z 6
+ tm31=formatf tm3.x 6
+ tm32=formatf tm3.y 6
+ tm33=formatf tm3.z 6
+ tm41=formatf tm4.x 6
+ tm42=formatf tm4.y 6
+ tm43=formatf tm4.z 6
+ format " dc.s %,%,%\n" tm11 tm12 tm13 to:out_file
+ format " dc.s %,%,%\n" tm21 tm22 tm23 to:out_file
+ format " dc.s %,%,%\n" tm31 tm32 tm33 to:out_file
+ format " dc.s %,%,%\n" tm41 tm42 tm43 to:out_file
+ format "\n" to:out_file
+ )
+
+ )
+
+ close out_file
+ shelllaunch "notepad.exe" filename
+
+)
+
+-- theend u3 = (int (getTVert theMesh tverts[3] * 65535).x)
+ v3 = 65536 - (int (getTVert theMesh tverts[3] * 65535).y)
+
+ if u1 > 65535 then u1 = 65535
+ if v1 > 65535 then v1 = 65535
+ if u2 > 65535 then u2 = 65535
+ if v2 > 65535 then v2 = 65535
+ if u3 > 65535 then u3 = 65535
+ if v3 > 65535 then v3 = 65535
+
+ /*
+ if u1 < 0 then u1 = 0
+ if v1 < 0 then v1 = 0
+ if u2 < 0 then u2 = 0
+ if v2 < 0 then v2 = 0
+ if u3 < 0 then u3 = 0
+ if v3 < 0 then v3 = 0
+ */
+
+ if mat.opacityMap != undefined then (
+ mattype = "2"
+ )
+ )
+ )
+
+ format " dc.w %\n" mattype to:out_file
+ format " dc.l %\n" matname to:out_file
+ format " dc.w %,%,%,%,%,%\n" u1 v1 u2 v2 u3 v3 to:out_file
+
+ )
+ format "\n" to:out_file
+
+ voff += themesh.numverts
+ )
+ )
+
+ format ";------------------------------------------------------------\n" to:out_file
+ format "; \n" to:out_file
+ format ";------------------------------------------------------------\n" to:out_file
+ format "\n" to:out_file
+ format "%_mtx\n" sname to:out_file
+ format "\n" to:out_file
+
+ for i = animationRange.start to animationRange.end do (
+
+ sliderTime=i
+
+ format "; index %\n" i to:out_file
+ format "\n" to:out_file
+
+ for j = 1 to objects.count do (
+
+ o=objects[j]
+
+ vpm=getViewTM()
+ tm=o.transform*vpm
+ tm1=tm.row1
+ tm2=tm.row2
+ tm3=tm.row3
+ tm4=tm.row4
+ tm11=formatf tm1.x 6
+ tm12=formatf tm1.y 6
+ tm13=formatf tm1.z 6
+ tm21=formatf tm2.x 6
+ tm22=formatf tm2.y 6
+ tm23=formatf tm2.z 6
+ tm31=formatf tm3.x 6
+ tm32=formatf tm3.y 6
+ tm33=formatf tm3.z 6
+ tm41=formatf tm4.x 6
+ tm42=formatf tm4.y 6
+ tm43=formatf tm4.z 6
+ format " dc.s %,%,%\n" tm11 tm12 tm13 to:out_file
+ format " dc.s %,%,%\n" tm21 tm22 tm23 to:out_file
+ format " dc.s %,%,%\n" tm31 tm32 tm33 to:out_file
+ format " dc.s %,%,%\n" tm41 tm42 tm43 to:out_file
+ format "\n" to:out_file
+ )
+
+ )
+
+ close out_file
+ shelllaunch "notepad.exe" filename
+
+)
+
+-- theend
+
+
+void DS3231::setDateTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second)
+{
+ Wire.beginTransmission(DS3231_ADDRESS);
+
+ #if ARDUINO >= 100
+ Wire.write(DS3231_REG_TIME);
+ #else
+ Wire.send(DS3231_REG_TIME);
+ #endif
+
+ #if ARDUINO >= 100
+ Wire.write(dec2bcd(second));
+ Wire.write(dec2bcd(minute));
+ Wire.write(dec2bcd(hour));
+ Wire.write(dec2bcd(dow(year, month, day)));
+ Wire.write(dec2bcd(day));
+ Wire.write(dec2bcd(month));
+ Wire.write(dec2bcd(year-2000));
+ #else
+ Wire.send(dec2bcd(second));
+ Wire.send(dec2bcd(minute));
+ Wire.send(dec2bcd(hour));
+ Wire.send(dec2bcd(dow(year, month, day)));
+ Wire.send(dec2bcd(day));
+ Wire.send(dec2bcd(month));
+ Wire.send(dec2bcd(year-2000));
+ #endif
+
+ #if ARDUINO >= 100
+ Wire.write(DS3231_REG_TIME);
+ #else
+ Wire.send(DS3231_REG_TIME);
+ #endif
+
+ Wire.endTransmission();
+}
- letter sequences ij (capitalized as IJ, and also found as a ligature, IJ or ij), ei, ou, au, oe, doubled vowels (but not ii), kw, ch, sch, oei, ooi, aai and uw (especially eeuw, ieuw, auw, and ouw).
- all consonants, except h, j, q, v, w, x and z can be doubled.
- the letters c (except in the sequence (s)ch), q, x and y are almost only found in loanwords.
- words: het, op, en, een, voor (and compounds of voor).
- word endings: -tje, -sje, -ing, -en, -lijk,
- at the start of words: z-, v-, ge-
- t/m occasionally occurs between two points in time or between numbers (e.g. house numbers).
+void DS3231::setDateTime(uint32_t t)
+{
+ t -= 946681200;
-West Frisian (Frysk)
+ uint16_t year;
+ uint8_t month;
+ uint8_t day;
+ uint8_t hour;
+ uint8_t minute;
+ uint8_t second;
- letter sequences: ij, ei, oa
- words: yn
+ second = t % 60;
+ t /= 60;
-Afrikaans (Afrikaans)
+ minute = t % 60;
+ t /= 60;
- Words: 'n, as, vir, nie.
- Similar to Dutch, but:
- the common Dutch letters c and z are rare and used only in loanwords (e.g. chalet);
- the common Dutch vowel ij is not used; instead, i and y are used (e.g. -lik, sy);
- the common Dutch word ending -en is rare, being replaced by -e.
+ hour = t % 24;
+ uint16_t days = t / 24;
+ uint8_t leap;
-German (Deutsch)
+ for (year = 0; ; ++year)
+ {
+ leap = year % 4 == 0;
+ if (days < 365 + leap)
+ {
+ break;
+ }
+ days -= 365 + leap;
+ }
- umlauts (ä, ö, ü), ess-zett (ß)
- letter sequences: ch, sch, tsch, tz, ss,
- common words: der, die, das, den, dem, des, er, sie, es, ist, ich, du, aber
- common endings: -en, -er, -ern, -st, -ung, -chen, -tät
- rare letters: x, y (except in loanwords)
- letter c rarely used except in the sequences listed above and in loanwords
- long compound words
- a period (.) after ordinal numbers, e.g. 3. Oktober
- many capitalised words in the middle of sentences since German capitalizes all nouns.
+ for (month = 1; ; ++month)
+ {
+ uint8_t daysPerMonth = pgm_read_byte(daysArray + month - 1);
-Swedish (Svenska)
+ if (leap && month == 2)
+ {
+ ++daysPerMonth;
+ }
- letters å, ä, ö, rarely é
- common words: och, i, att, det, en, som, är, av, den, på, om, inte, men
- common endings: -ning, -lig, -isk, -ande, -ade, -era, -rna
- common surname endings: -sson, -berg, -borg, -gren, -lund, -lind, -ström, -kvist/qvist/quist
- long compound words
- letter sequences: stj, sj, skj, tj, ck, än
- no use of characters w, z except for foreign proper nouns and some loanwords but x is used, unlike Danish and Norwegian, which replace it with ks
- doubling of consonants common, but doubling of vowels very rare
+ if (days < daysPerMonth)
+ {
+ break;
+ }
+ days -= daysPerMonth;
+ }
-Danish (Dansk)
+ day = days + 1;
- letters æ, ø, å
- common words: af, og, til, er, på, med, det, den;
- common endings: -tion, -ing, -else, -hed;
- long compound words;
- no use of character q, w, x and z except for foreign proper nouns and some loanwords;
- to distinguish from Norwegian: uses letter combination øj; frequent use of æ; spellings of borrowed foreign words are retained (in particular use of c), such as centralstation.
- doubling of consonants common, but doubling of vowels very rare
+ setDateTime(year+2000, month, day, hour, minute, second);
+}
-Norwegian (Norsk)
+void DS3231::setDateTime(const char* date, const char* time)
+{
+ uint16_t year;
+ uint8_t month;
+ uint8_t day;
+ uint8_t hour;
+ uint8_t minute;
+ uint8_t second;
- letters æ, ø, å
- common words: av, ble, er, og, en, et, men, i, å, for, eller;
- common endings: -sjon, -ing, -else, -het;
- long compound words;
- no use of character c, w, z and x except for foreign proper nouns and some loanwords;
- two versions of the language: Bokmål (much closer to Danish) and Nynorsk – for example ikke, lørdag, Norge (Bokmål) vs. ikkje, laurdag, Noreg (Nynorsk); Nynorsk uses the word òg; printed materials almost always published in Bokmål only;
- to distinguish from Danish: uses letter combination øy; less frequent use of æ; spellings of borrowed foreign words are ‘Norsified’ (in particular removing use of c), such as sentralstasjon.
- doubling of consonants common, but doubling of vowels very rare
+ year = conv2d(date + 9);
-Icelandic (Íslenska)
+ switch (date[0])
+ {
+ case 'J': month = date[1] == 'a' ? 1 : month = date[2] == 'n' ? 6 : 7; break;
+ case 'F': month = 2; break;
+ case 'A': month = date[2] == 'r' ? 4 : 8; break;
+ case 'M': month = date[2] == 'r' ? 3 : 5; break;
+ case 'S': month = 9; break;
+ case 'O': month = 10; break;
+ case 'N': month = 11; break;
+ case 'D': month = 12; break;
+ }
- letters á, ð, é, í, ó, ú, ý, þ, æ, ö
- common beginnings: fj-, gj-, hj-, hl-, hr-, hv-, kj-, and sj-,
- common endings: -ar (especially -nar), -ir (especially -nir), -ur, -nn (especially -inn)
- no use of character c, q, w, or z except for foreign proper nouns, some loanwords, and, in the case of z, older texts.
- doubling of consonants common, but doubling of vowels very rare
+ day = conv2d(date + 4);
+ hour = conv2d(time);
+ minute = conv2d(time + 3);
+ second = conv2d(time + 6);
-Faroese (Føroyskt)
+ setDateTime(year+2000, month, day, hour, minute, second);
+}
- letters á, ð, í, ó, ú, ý, æ, ø
- letter combinations: ggj, oy, skt
- to distinguish from Icelandic: does not use é or þ, uses ø instead of ö (occasionally rendered as ö on road signs, or even ő).
- doubling of consonants common, but doubling of vowels very rare
+char* DS3231::dateFormat(const char* dateFormat, RTCDateTime dt)
+{
+ char buffer[255];
-Baltic languages
-Latvian (Latviešu)
+ buffer[0] = 0;
- uses diacritics: ā, č, ē, ģ, ī, ķ, ļ, ņ, ō, ŗ, š, ū, ž
- does not have letters: q, w, x, y
- no longer uses ō or ŗ in modern language
- extremely rare doubling of vowels
- rare doubling of consonants
- a period (.) after ordinal numbers, e.g. 2005. gads
- common words: ir, bija, tika, es, viņš
+ char helper[11];
-Lithuanian (Lietuvių)
+ while (*dateFormat != '\0')
+ {
+ switch (dateFormat[0])
+ {
+ // Day decoder
+ case 'd':
+ sprintf(helper, "%02d", dt.day);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'j':
+ sprintf(helper, "%d", dt.day);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'l':
+ strcat(buffer, (const char *)strDayOfWeek(dt.dayOfWeek));
+ break;
+ case 'D':
+ strncat(buffer, strDayOfWeek(dt.dayOfWeek), 3);
+ break;
+ case 'N':
+ sprintf(helper, "%d", dt.dayOfWeek);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'w':
+ sprintf(helper, "%d", (dt.dayOfWeek + 7) % 7);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'z':
+ sprintf(helper, "%d", dayInYear(dt.year, dt.month, dt.day)+1);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'S':
+ strcat(buffer, (const char *)strDaySufix(dt.day));
+ break;
+
+ // Month decoder
+ case 'm':
+ sprintf(helper, "%02d", dt.month);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'n':
+ sprintf(helper, "%d", dt.month);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'F':
+ strcat(buffer, (const char *)strMonth(dt.month));
+ break;
+ case 'M':
+ strncat(buffer, (const char *)strMonth(dt.month), 3);
+ break;
+ case 't':
+ sprintf(helper, "%d", daysInMonth(dt.year, dt.month));
+ strcat(buffer, (const char *)helper);
+ break;
+
+ // Year decoder
+ case 'Y':
+ sprintf(helper, "%d", dt.year);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'y': sprintf(helper, "%02d", dt.year-2000);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'L':
+ sprintf(helper, "%d", isLeapYear(dt.year));
+ strcat(buffer, (const char *)helper);
+ break;
+
+ // Hour decoder
+ case 'H':
+ sprintf(helper, "%02d", dt.hour);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'G':
+ sprintf(helper, "%d", dt.hour);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'h':
+ sprintf(helper, "%02d", hour12(dt.hour));
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'g':
+ sprintf(helper, "%d", hour12(dt.hour));
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'A':
+ strcat(buffer, (const char *)strAmPm(dt.hour, true));
+ break;
+ case 'a':
+ strcat(buffer, (const char *)strAmPm(dt.hour, false));
+ break;
+
+ // Minute decoder
+ case 'i':
+ sprintf(helper, "%02d", dt.minute);
+ strcat(buffer, (const char *)helper);
+ break;
+
+ // Second decoder
+ case 's':
+ sprintf(helper, "%02d", dt.second);
+ strcat(buffer, (const char *)helper);
+ break;
+
+ // Misc decoder
+ case 'U':
+ sprintf(helper, "%lu", dt.unixtime);
+ strcat(buffer, (const char *)helper);
+ break;
+
+ default:
+ strncat(buffer, dateFormat, 1);
+ break;
+ }
+ dateFormat++;
+ }
- visual abundance of letters ą, č, ę, ė, į, š, ų, ū, ų
- does not have letters q, w, x
- extremely rare doubling of vowels and consonants
- many varying forms (usually endings) of the same word, e.g. namas, namo, namus, namams, etc.
- generally long words (absence of articles and fewer prepositions in comparison to Germanic languages)
- common words: ir, yra, kad, bet.
+ return buffer;
+}
-Slavic languages
-Polish (Polski)
+char* DS3231::dateFormat(const char* dateFormat, RTCAlarmTime dt)
+{
+ char buffer[255];
- consonant clusters rz, sz, cz, prz, trz
- includes: ą, ę, ć, ś, ł, ń, ó, ż, ź
- words w, z, we, i, na (several one-letter words)
- words jest, się
- words beginning with był, będzie, jest (forms of copula być, "to be").
+ buffer[0] = 0;
-Czech (Čeština)
+ char helper[11];
- visual abundance of letters ž š ů ě ř
- words je, v
- to distinguish from Slovak: does not use ä, ľ, ĺ, ŕ or ô; ú only appears at the beginning of words.
+ while (*dateFormat != '\0')
+ {
+ switch (dateFormat[0])
+ {
+ // Day decoder
+ case 'd':
+ sprintf(helper, "%02d", dt.day);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'j':
+ sprintf(helper, "%d", dt.day);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'l':
+ strcat(buffer, (const char *)strDayOfWeek(dt.day));
+ break;
+ case 'D':
+ strncat(buffer, strDayOfWeek(dt.day), 3);
+ break;
+ case 'N':
+ sprintf(helper, "%d", dt.day);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'w':
+ sprintf(helper, "%d", (dt.day + 7) % 7);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'S':
+ strcat(buffer, (const char *)strDaySufix(dt.day));
+ break;
+
+ // Hour decoder
+ case 'H':
+ sprintf(helper, "%02d", dt.hour);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'G':
+ sprintf(helper, "%d", dt.hour);
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'h':
+ sprintf(helper, "%02d", hour12(dt.hour));
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'g':
+ sprintf(helper, "%d", hour12(dt.hour));
+ strcat(buffer, (const char *)helper);
+ break;
+ case 'A':
+ strcat(buffer, (const char *)strAmPm(dt.hour, true));
+ break;
+ case 'a':
+ strcat(buffer, (const char *)strAmPm(dt.hour, false));
+ break;
+
+ // Minute decoder
+ case 'i':
+ sprintf(helper, "%02d", dt.minute);
+ strcat(buffer, (const char *)helper);
+ break;
+
+ // Second decoder
+ case 's':
+ sprintf(helper, "%02d", dt.second);
+ strcat(buffer, (const char *)helper);
+ break;
+
+ default:
+ strncat(buffer, dateFormat, 1);
+ break;
+ }
+ dateFormat++;
+ }
-Slovak (Slovenčina)
+ return buffer;
+}
- visual abundance of letters ž š č;
- uses: ä, ľ, and ô and (very rarely) ĺ and ŕ;
- typical suffixes: -cia, -ť;
- to distinguish from Czech: does not use ě, ř or ů.
+RTCDateTime DS3231::getDateTime(void)
+{
+ int values[7];
-Croatian (Hrvatski)
+ Wire.beginTransmission(DS3231_ADDRESS);
+ #if ARDUINO >= 100
+ Wire.write(DS3231_REG_TIME);
+ #else
+ Wire.send(DS3231_REG_TIME);
+ #endif
+ Wire.endTransmission();
- similar to Serbian
- letters-digraphs dž, lj, nj
- does not have q, w, x, y
- typical suffixes: -ti, -ći
- special letters: č, ć, š, ž, đ
- common words: a, i, u, je
- to distinguish from Serbian: sequences -ije- and -je- are common; verbs ending in -irati, -iran
+ Wire.requestFrom(DS3231_ADDRESS, 7);
-Serbian (Srpski/Српски)
-Serbian Latin
+ while(!Wire.available()) {};
- similar to Croatian
- letters-digraphs dž, lj, nj (lj and nj are somewhat more common than dž, although not by much)
- no q, w, x, y
- typical verb suffixes -ti, -ći (infinitive is much less used than in Croatian)
- foreign words might end in -tija, -ovan, -ovati, -uje
- special letters: đ (rare), č, š (common), ć, ž (less common)
- common words: a, i, u, je, jeste
- future tense suffix -iće, -ićeš, -ićemo, -ićete (not found in Croatian)
- vowel sequences -ije- and -je- are very often in Serbian that is spoken in Bosnia and Herzegovina, Montenegro and Croatia (ijekavica), but it does not appear in Serbia because each of those sequences are substituted with -e- (ekavica).
+ for (int i = 6; i >= 0; i--)
+ {
+ #if ARDUINO >= 100
+ values[i] = bcd2dec(Wire.read());
+ #else
+ values[i] = bcd2dec(Wire.receive());
+ #endif
+ }
-Serbian Cyrillic
+ Wire.endTransmission();
- uses Џ, Ј, Љ, Њ, Ђ, Ћ
- does not use Щ, Ъ, Ы, Ь, Э, Ю, Я, Ё, Є, Ґ, Ї, І, Ў
- to distinguish from Macedonian: does not use Ѕ, Ѓ, Ќ
+ t.year = values[0] + 2000;
+ t.month = values[1];
+ t.day = values[2];
+ t.dayOfWeek = values[3];
+ t.hour = values[4];
+ t.minute = values[5];
+ t.second = values[6];
+ t.unixtime = unixtime();
-Celtic languages
-Welsh (Cymraeg)
+ return t;
+}
- letters Ŵ, ŵ used in Welsh
- words y, yr, yn, a, ac, i, o
- letter sequences wy, ch, dd, ff, ll, mh, ngh, nh, ph, rh, th, si
- letters not used: k, q, v, x, z
- letter only used rarely, in loanwords: j
- commonly accented letters: â, ê, î, ô, û, ŵ, ŷ, although acute (´), grave (`), and dieresis (¨) accents can hypothetically occur on all vowels
- word endings: -ion, -au, -wr, -wyr
- y is the most common letter in the language
- w between consonants (w in fact represents a vowel in the Welsh language)
- circumflex accent (^) is by far the commonest diacritical mark, although diacritics are often omitted altogether
+uint8_t DS3231::isReady(void)
+{
+ return true;
+}
-Irish (Gaeilge)
+void DS3231::enableOutput(bool enabled)
+{
+ uint8_t value;
- vowels with acute accents: á é í ó ú
- words beginning with letter sequences bp dt gc bhf
- letter sequences sc cht
- no use of the letter J, K, Q, V, W.
- frequent bh, ch, dh, fh, gh, mh, th, sh
- to distinguish from (Scottish) Gaelic: there may be words or names with the second (or even third) letter capitalized instead of the first: hÉireann.
+ value = readRegister8(DS3231_REG_CONTROL);
-Scottish Gaelic (Gàidhlig)
+ value &= 0b11111011;
+ value |= (!enabled << 2);
- vowels with grave accents: à è ì ò ù (é and ó still occasionally seen but usage is now discouraged)
- letter sequences sg chd
- frequent bh, ch, dh, fh, gh, mh, th, sh
- to distinguish from Irish: prefixes are hyphenated, so capitals in the middle of words generally do not occur: an t-Oban.
+ writeRegister8(DS3231_REG_CONTROL, value);
+}
-Albanian (Shqip)
+void DS3231::setBattery(bool timeBattery, bool squareBattery)
+{
+ uint8_t value;
- unique letters: ë, ç.
- ë is the most common letter in the language.
- the letter w is not used except in loanwords.
- dh, gj, ll, nj, rr, sh, th, xh, and zh are considered one letter instead of two.
- common words: po, jo, dhe, i, të, me
+ value = readRegister8(DS3231_REG_CONTROL);
-Maltese (Malti)
+ if (squareBattery)
+ {
+ value |= 0b01000000;
+ } else
+ {
+ value &= 0b10111111;
+ }
- unique letters: ċ, ġ, ħ, għ, ħ, ż
- semitic origin, fairly intelligible with Arabic
- uses il-xxx for the definite article
+ if (timeBattery)
+ {
+ value &= 0b01111011;
+ } else
+ {
+ value |= 0b10000000;
+ }
-Iranian languages
-Kurdish (Kurdî / كوردی)
+ writeRegister8(DS3231_REG_CONTROL, value);
+}
- uses circumflex ( ^ ): ê, î, û and cedilla ( ¸ ): ç, ş
- the word xwe (oneself, myself, yourself etc.) appears frequently and is highly specific (xw combination)
- ( I, i ) is the most common letter in the language
- uses eight vowels (a, e, ê, i, î, o, u, û)
- impossible to find a word without any vowel
- has lots of compound words
+bool DS3231::isOutput(void)
+{
+ uint8_t value;
-Finno-Ugric languages
-Finnish (Suomi)
+ value = readRegister8(DS3231_REG_CONTROL);
- distinct letters å, ä and ö; but never õ or ü (y takes the place of ü)
- b, f, z, š and ž appear in loanwords and proper names only; the last two are substituted with sh or zh in some texts
- c, q, w, x, å appear in (typically foreign) proper names only
- outside of loanwords, d appears only between vowels or in hd
- outside of loanwords, g only appears in ng
- outside of loanwords, words do not begin with two consonants; this is reflected in the general syllable structure, where consonant clusters only occur across syllable boundaries, except in some loanwords
- common words: sinä, on
- common endings: -nen, -ka/-kä, -in, -t (plural suffix)
- common vowel combinations: ai, uo, ei, ie, oi, yö, äi
- unusually high degree of letter duplication, both vowels and consonants will be geminated, for example aa, ee, ii, kk, ll, ss, yy, ää
- frequent long words
+ value &= 0b00000100;
+ value >>= 2;
-Estonian (Eesti)
+ return !value;
+}
- distinct letters: õ, ä, ö and ü; but never ß or å
- similar to Finnish, except:
- letter y is not used, except in loanwords (ü is the corresponding vowel)
- letters b and g (without preceding n) are found outside of loanwords
- occasional use of š and ž, mainly in loanwords (plus combination tš)
- loanwords more common generally than in Finnish, mainly loaned from German
- words end in consonants more frequently than in Finnish, word-final b, d, v being particularly typical
- letter d is much more common in Estonian than in Finnish, and in Estonian it is often the last letter of the word (plural suffix), which it never is in Finnish
- double öö more common than in Finnish; other doubles can include õõ, üü, rarely hh (for German ch) and even šš
- common words: ja, on, ei, ta, see, või.
+void DS3231::setOutput(DS3231_sqw_t mode)
+{
+ uint8_t value;
-Hungarian (Magyar)
+ value = readRegister8(DS3231_REG_CONTROL);
- letters ő and ű (double acute accent) unique to Hungarian
- accented letters á and é frequent
- letter combinations: cs, dz, dzs, gy, ly, ny, sz, ty, zs (all classed as separate letters), leg‐, ‐obb (note: sz also common in Polish)
- common words: a, az, ez, egy, és, van, hogy
- letter k very frequent (plural suffix)
+ value &= 0b11100111;
+ value |= (mode << 3);
-Eskimo–Aleut languages
-Greenlandic
+ writeRegister8(DS3231_REG_CONTROL, value);
+}
- long polysynthetic words (a single word can number 30+ letters)
- relatively abundant n, q (not necessarily followed by u), u
- ubiquitous double consonants and vowels (aa, ii, qq, uu, more rarely ee, oo)
- vowels a, i, u conspicuously more frequent than e, o (which are only found before q and r)
- no diphthongs except occasional word-final ai, only consonant combinations besides double consonants and (n)ng consist of r + consonant
- old spellings (now abolished in spelling reform) sometimes included acute accent, circumflex and/or tilde: Qânâq vs. Qaanaaq.
+DS3231_sqw_t DS3231::getOutput(void)
+{
+ uint8_t value;
-Southern Athabaskan languages
+ value = readRegister8(DS3231_REG_CONTROL);
- vowels with acute accent, ogonek (nasal hook), or both: á, ą, ą́
- doubled vowels: aa, áá, ąą, ą́ą́
- slashed l: ł (check not Polish!)
- n with acute accent: ń
- quotation mark: ' or ’
- sequences: dl, tł, tł’, dz, ts’, ií, áa, aá
- may have rather long words
+ value &= 0b00011000;
+ value >>= 3;
-Navajo (Diné bizaad)
+ return (DS3231_sqw_t)value;
+}
+
+void DS3231::enable32kHz(bool enabled)
+{
+ uint8_t value;
+
+ value = readRegister8(DS3231_REG_STATUS);
+
+ value &= 0b11110111;
+ value |= (enabled << 3);
+
+ writeRegister8(DS3231_REG_STATUS, value);
+}
+
+bool DS3231::is32kHz(void)
+{
+ uint8_t value;
-In addition to the above,
+ value = readRegister8(DS3231_REG_STATUS);
- does not use u, ú, or ų
+ value &= 0b00001000;
+ value >>= 3;
-(Mescalero / Chiricahua) (Mashgaléń / Chidikáágo)
+ return value;
+}
-In addition to the above,
- uses: u, ú, ų
- does not use o, ó, or ǫ
+#ifndef DS3231_h
+#define DS3231_h
-Guaraní
+#if ARDUINO >= 100
+#include "Arduino.h"
+#else
+#include "WProgram.h"
+#endif
- lots of tildes over vowels (including y) and n
- tilde over g: g̃—it's the only language in the world to use it. Example words: hagũa and g̃uahẽ.
- b, d, and g usually do not occur without m or n before (mb, nd, ng) unless they're Spanish loan words.
- f, l, q, w, x, z extremely rare outside loan words
- does not use c without h: ch
+#define DS3231_ADDRESS (0x68)
-Japanese in Romaji (Nihongo/日本語)
+#define DS3231_REG_TIME (0x00)
+#define DS3231_REG_ALARM_1 (0x07)
+#define DS3231_REG_ALARM_2 (0x0B)
+#define DS3231_REG_CONTROL (0x0E)
+#define DS3231_REG_STATUS (0x0F)
+#define DS3231_REG_TEMPERATURE (0x11)
- words: desu, aru, suru, esp. at end of sentences;
- word endings: -masu, -masen, -shita;
- letters: Japanese almost always alternates between a consonant and a vowel. Exceptions are digraphs shi and chi, affricate tsu, gemination (two of the same consonant in a row) and palatalization (a consonant followed by the letter y).
- a macron or circumflex may be used to indicate doubled vowels, eg. Tōkyō
- common words: no, o, wa, de, ni
+#ifndef RTCDATETIME_STRUCT_H
+#define RTCDATETIME_STRUCT_H
+struct RTCDateTime
+{
+ uint16_t year;
+ uint8_t month;
+ uint8_t day;
+ uint8_t hour;
+ uint8_t minute;
+ uint8_t second;
+ uint8_t dayOfWeek;
+ uint32_t unixtime;
+};
-(Note: Romaji is not often used in Japanese script. It is most often used for foreigners learning the pronunciation of the Japanese language.)
-Hmong (Hmoob) written in Romanized Popular Alphabet
+struct RTCAlarmTime
+{
+ uint8_t day;
+ uint8_t hour;
+ uint8_t minute;
+ uint8_t second;
+};
+#endif
- Almost all written words are quite short (one syllable).
- Syllables (unless they are pronounced with mid tone) end in a tone letter: one of b s j v m g d, leading to apparent "consonant clusters" such as -wj
- w can be the main vowel of a syllable (e.g. tswv)
- Syllables can begin with sequences such as hm-, ntxh-, nq-.
- Syllables ending in double vowels (especially -oo, -ee) possibly followed by a tone letters (as in Hmoob "Hmong").
+typedef enum
+{
+ DS3231_1HZ = 0x00,
+ DS3231_4096HZ = 0x01,
+ DS3231_8192HZ = 0x02,
+ DS3231_32768HZ = 0x03
+} DS3231_sqw_t;
-Vietnamese (tiếng Việt)
+typedef enum
+{
+ DS3231_EVERY_SECOND = 0b00001111,
+ DS3231_MATCH_S = 0b00001110,
+ DS3231_MATCH_M_S = 0b00001100,
+ DS3231_MATCH_H_M_S = 0b00001000,
+ DS3231_MATCH_DT_H_M_S = 0b00000000,
+ DS3231_MATCH_DY_H_M_S = 0b00010000
+} DS3231_alarm1_t;
+
+typedef enum
+{
+ DS3231_EVERY_MINUTE = 0b00001110,
+ DS3231_MATCH_M = 0b00001100,
+ DS3231_MATCH_H_M = 0b00001000,
+ DS3231_MATCH_DT_H_M = 0b00000000,
+ DS3231_MATCH_DY_H_M = 0b00010000
+} DS3231_alarm2_t;
+
+class DS3231
+{
+ public:
+
+ bool begin(void);
+
+ void setDateTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
+ void setDateTime(uint32_t t);
+ void setDateTime(const char* date, const char* time);
+ RTCDateTime getDateTime(void);
+ uint8_t isReady(void);
+
+ DS3231_sqw_t getOutput(void);
+ void setOutput(DS3231_sqw_t mode);
+ void enableOutput(bool enabled);
+ bool isOutput(void);
+ void enable32kHz(bool enabled);
+ bool is32kHz(void);
+
+ void forceConversion(void);
+ float readTemperature(void);
+
+ void setAlarm1(uint8_t dydw, uint8_t hour, uint8_t minute, uint8_t second, DS3231_alarm1_t mode, bool armed = true);
+ RTCAlarmTime getAlarm1(void);
+ DS3231_alarm1_t getAlarmType1(void);
+ bool isAlarm1(bool clear = true);
+ void armAlarm1(bool armed);
+ bool isArmed1(void);
+ void clearAlarm1(void);
+
+ void setAlarm2(uint8_t dydw, uint8_t hour, uint8_t minute, DS3231_alarm2_t mode, bool armed = true);
+ RTCAlarmTime getAlarm2(void);
+ DS3231_alarm2_t getAlarmType2(void);
+ bool isAlarm2(bool clear = true);
+ void armAlarm2(bool armed);
+ bool isArmed2(void);
+ void clearAlarm2(void);
+
+ void setBattery(bool timeBattery, bool squareBattery);
+
+ char* dateFormat(const char* dateFormat, RTCDateTime dt);
+ char* dateFormat(const char* dateFormat, RTCAlarmTime dt);
+
+ private:
+ RTCDateTime t;
+
+ char *strDayOfWeek(uint8_t dayOfWeek);
+ char *strMonth(uint8_t month);
+ char *strAmPm(uint8_t hour, bool uppercase);
+ char *strDaySufix(uint8_t day);
+
+ uint8_t hour12(uint8_t hour24);
+ uint8_t bcd2dec(uint8_t bcd);
+ uint8_t dec2bcd(uint8_t dec);
+
+ long time2long(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds);
+ uint16_t date2days(uint16_t year, uint8_t month, uint8_t day);
+ uint8_t daysInMonth(uint16_t year, uint8_t month);
+ uint16_t dayInYear(uint16_t year, uint8_t month, uint8_t day);
+ bool isLeapYear(uint16_t year);
+ uint8_t dow(uint16_t y, uint8_t m, uint8_t d);
+
+ uint32_t unixtime(void);
+ uint8_t conv2d(const char* p);
+
+ void writeRegister8(uint8_t reg, uint8_t value);
+ uint8_t readRegister8(uint8_t reg);
+};
- Roman characters with more than one diacritical mark on the same vowel. See above.
- Almost all written words are quite short (one syllable, mostly less than six characters long).
- Words beginning with ng or ngh
- Words ending with nh
- common words: cái, không, có, ở, của, và, tại, với, để, đã, sẽ, đang, tôi, bạn, chúng, là
+#endif
-Vietnamese Quoted-Readable (VIQR)
+#include
+#include
+#include
+#include
+#include
+#include
+#include
- The following characters (often in combination) after vowels: ^ ( + ' ` ? ~ .
- DD, Dd, or dd
- The following character before punctuation: \
+#define cudaCheck(err) (cudaCheck(err, __FILE__, __LINE__))
-Vietnamese VNI encoding
+const std::string errLogFile = "matrixValidationFailure.txt";
- The digits 1-8 after vowels
- The digit 9 after a D or d
- The following character before numbers: \
+int main(int argc, char **argv) {
+ if (argc != 2) {
+ std::cerr << "Please select a kernel (range 0 - 12, 0 for NVIDIA cuBLAS)"
+ << std::endl;
+ exit(EXIT_FAILURE);
+ }
-Vietnamese Telex
+ // get kernel number
+ int kernel_num = std::stoi(argv[1]);
+ if (kernel_num < 0 || kernel_num > 12) {
+ std::cerr << "Please enter a valid kernel number (0-12)" << std::endl;
+ exit(EXIT_FAILURE);
+ }
- The following characters after vowels: s f r x j
- The following vowels, doubled up: a e o
- The letter w after the following characters: a o u
- DD, Dd, or dd
+ // get environment variable for device
+ int deviceIdx = 0;
+ if (getenv("DEVICE") != NULL) {
+ deviceIdx = atoi(getenv("DEVICE"));
+ }
+ cudaCheck(cudaSetDevice(deviceIdx));
+
+ printf("Running kernel %d on device %d.\n", kernel_num, deviceIdx);
+
+ // print some device info
+ // CudaDeviceInfo();
+
+ // Declare the handle, create the handle, cublasCreate will return a value of
+ // type cublasStatus_t to determine whether the handle was created
+ // successfully (the value is 0)
+ cublasHandle_t handle;
+ if (cublasCreate(&handle)) {
+ std::cerr << "Create cublas handle error." << std::endl;
+ exit(EXIT_FAILURE);
+ };
+
+ // Using cudaEvent for gpu stream timing, cudaEvent is equivalent to
+ // publishing event tasks in the target stream
+ float elapsed_time;
+ cudaEvent_t beg, end;
+ cudaEventCreate(&beg);
+ cudaEventCreate(&end);
+
+ // cuBLAS FLOPs ceiling is reached at 8192
+ std::vector SIZE = {128, 256, 512, 1024, 2048, 4096};
+
+ long m, n, k, max_size;
+ max_size = SIZE[SIZE.size() - 1];
+ std::cout << "Max size: " << max_size << std::endl;
+
+ float alpha = 0.5, beta = 3.0; // GEMM input parameters, C=α*AB+β*C
+
+ float *A = nullptr, *B = nullptr, *C = nullptr,
+ *C_ref = nullptr; // host matrices
+ float *dA = nullptr, *dB = nullptr, *dC = nullptr,
+ *dC_ref = nullptr; // device matrices
+
+ A = (float *)malloc(sizeof(float) * max_size * max_size);
+ B = (float *)malloc(sizeof(float) * max_size * max_size);
+ C = (float *)malloc(sizeof(float) * max_size * max_size);
+ C_ref = (float *)malloc(sizeof(float) * max_size * max_size);
+
+ randomize_matrix(A, max_size * max_size);
+ randomize_matrix(B, max_size * max_size);
+ randomize_matrix(C, max_size * max_size);
+
+ cudaCheck(cudaMalloc((void **)&dA, sizeof(float) * max_size * max_size));
+ cudaCheck(cudaMalloc((void **)&dB, sizeof(float) * max_size * max_size));
+ cudaCheck(cudaMalloc((void **)&dC, sizeof(float) * max_size * max_size));
+ cudaCheck(cudaMalloc((void **)&dC_ref, sizeof(float) * max_size * max_size));
+
+ cudaCheck(cudaMemcpy(dA, A, sizeof(float) * max_size * max_size,
+ cudaMemcpyHostToDevice));
+ cudaCheck(cudaMemcpy(dB, B, sizeof(float) * max_size * max_size,
+ cudaMemcpyHostToDevice));
+ cudaCheck(cudaMemcpy(dC, C, sizeof(float) * max_size * max_size,
+ cudaMemcpyHostToDevice));
+ cudaCheck(cudaMemcpy(dC_ref, C, sizeof(float) * max_size * max_size,
+ cudaMemcpyHostToDevice));
+
+ int repeat_times = 50;
+ for (int size : SIZE) {
+ m = 32;
+ n = k = size;
+
+ std::cout << "dimensions(m,n,k) " << m << "," << n << "," << k << ", alpha: " << alpha
+ << ", beta: " << beta << std::endl;
+ // Verify the correctness of the calculation, and execute it once before the
+ // kernel function timing to avoid cold start errors
+ if (kernel_num != 0) {
+ run_kernel(0, m, n, k, alpha, dA, dB, beta, dC_ref,
+ handle); // cuBLAS
+ run_kernel(kernel_num, m, n, k, alpha, dA, dB, beta, dC,
+ handle); // Executes the kernel, modifies the result matrix
+ cudaCheck(cudaDeviceSynchronize());
+ cudaCheck(cudaGetLastError()); // Check for async errors during kernel run
+ cudaMemcpy(C, dC, sizeof(float) * m * n, cudaMemcpyDeviceToHost);
+ cudaMemcpy(C_ref, dC_ref, sizeof(float) * m * n, cudaMemcpyDeviceToHost);
+
+ if (!verify_matrix(C_ref, C, m * n)) {
+ std::cout
+ << "Failed to pass the correctness verification against NVIDIA "
+ "cuBLAS."
+ << std::endl;
+ if (m <= 128) {
+ std::cout << " Logging faulty output into " << errLogFile << "\n";
+ std::ofstream fs;
+ fs.open(errLogFile);
+ fs << "A:\n";
+ print_matrix(A, m, n, fs);
+ fs << "B:\n";
+ print_matrix(B, m, n, fs);
+ fs << "C:\n";
+ print_matrix(C, m, n, fs);
+ fs << "Should:\n";
+ print_matrix(C_ref, m, n, fs);
+ }
+ exit(EXIT_FAILURE);
+ }
+ }
-Chinese, Romanized
-Standard Mandarin (現代標準漢語)
+ cudaEventRecord(beg);
+ for (int j = 0; j < repeat_times; j++) {
+ // We don't reset dC between runs to save time
+ run_kernel(kernel_num, m, n, k, alpha, dA, dB, beta, dC, handle);
+ }
+ cudaEventRecord(end);
+ cudaEventSynchronize(beg);
+ cudaEventSynchronize(end);
+ cudaEventElapsedTime(&elapsed_time, beg, end);
+ elapsed_time /= 1000.; // Convert to seconds
+
+ long flops = 2 * m * n * k;
+ printf(
+ "Average elapsed time: (%7.6f) s, performance: (%7.1f) GFLOPS. size: "
+ "(%ld).\n",
+ elapsed_time / repeat_times,
+ (repeat_times * flops * 1e-9) / elapsed_time, m);
+ fflush(stdout);
+ // make dC and dC_ref equal again (we modified dC while calling our kernel
+ // for benchmarking)
+ cudaCheck(cudaMemcpy(dC, dC_ref, sizeof(float) * m * n,
+ cudaMemcpyDeviceToDevice));
+ }
- In general, Mandarin syllables end only in vowels or n, ng, r; never in p, t, k, m
+ // Free up CPU and GPU space
+ free(A);
+ free(B);
+ free(C);
+ free(C_ref);
+ cudaFree(dA);
+ cudaFree(dB);
+ cudaFree(dC);
+ cudaFree(dC_ref);
+ cublasDestroy(handle);
+
+ return 0;
+};
-Pinyin
+#include
+#include
+#include
- Words beginning with x, q, zh
- Tone marks on vowels, such as ā, á, ǎ, à
- For convenience while using a computer, these are sometimes substituted with numbers, e.g. a1, a2, a3, a4
+__global__ void kernel(uint *A, uint *B, int row) {
+ auto x = threadIdx.x / 4;
+ auto y = threadIdx.x % 4;
+ A[x * row + y] = x;
+ B[x * row + y] = y;
+}
-Wade–Giles
+int main(int argc, char **argv) {
+ uint *Xs, *Ys;
+ uint *Xs_d, *Ys_d;
- Words do not begin with b, d, g, z, q, x, r
- Words beginning with hs
- Many hyphenated words
- Apostrophes after initial letters or digraphs, e.g. t'a, ch'i
+ uint SIZE = 4;
-Gwoyeu Romatzyh
+ Xs = (uint *)malloc(SIZE * SIZE * sizeof(uint));
+ Ys = (uint *)malloc(SIZE * SIZE * sizeof(uint));
- Many unusual vowel combinations such as ae, eei, ii, iee, oou, yy, etc.
- Insertion of r, e.g. arn, erng, etc.
- Words ending in nn, nq
+ cudaMalloc((void **)&Xs_d, SIZE * SIZE * sizeof(uint));
+ cudaMalloc((void **)&Ys_d, SIZE * SIZE * sizeof(uint));
-Southern Min / Min-Nan (Bân-lâm-gí/Bân-lâm-gú) in Pe̍h-ōe-jī
+ dim3 grid_size(1, 1, 1);
+ dim3 block_size(4 * 4);
- Many hyphenated words.
- Words can end in p, t, k, m, n, ng, h; never r
- Roman characters with many diacritical marks on vowels. Unlike Vietnamese, each character has at most one such mark.
- Unusual combining characters, namely · (middle dot, always after o) and | (vertical bar). ¯ (macron) is also common.
+ kernel<<>>(Xs_d, Ys_d, 4);
-Austronesian languages
-Malay (bahasa Melayu) and Indonesian (bahasa Indonesia)
+ cudaMemcpy(Xs, Xs_d, SIZE * SIZE * sizeof(uint), cudaMemcpyDeviceToHost);
+ cudaMemcpy(Ys, Ys_d, SIZE * SIZE * sizeof(uint), cudaMemcpyDeviceToHost);
-May contain the following:
-Prefixes: me-, mem-, memper-, pe-, per-, di-, ke-
-Suffixes: -kan, -an, -i
-Others (these almost always written in lowercase): yang, dan, di, ke, oleh, itu
+ cudaDeviceSynchronize();
-Malay and Indonesian are mutually intelligible to proficient speakers, although translators and interpreters will generally be specialists in one or other language. See Comparison of Standard Malay and Indonesian.
+ for (int row = 0; row < SIZE; ++row) {
+ for (int col = 0; col < SIZE; ++col) {
+ std::cout << "[" << Xs[row * SIZE + col] << "|" << Ys[row * SIZE + col]
+ << "] ";
+ }
+ std::cout << "\n";
+ }
-Frequent use of the letter 'a' (comparable to the frequency of the English 'e').
-Polynesian languages
+ cudaFree(Xs_d);
+ cudaFree(Ys_d);
+ free(Xs);
+ free(Ys);
+}
-Most Polynesian languages use A E F G H I K L M N O P R S T U V and ʻ (sometimes written ' or Q)
+name: SGEMM_CUDA
+channels:
+ - conda-forge
+dependencies:
+ - python
+ - black
+ - cmake
+ - matplotlib
+ - seaborn
+ - tabulate
- L : Nuclear Polynesian languages (Tongan, Samoan, Tuvaluan, Tokelauan...) as in fale
- R : Eastern Polynesian languages (NZ Māori, Tahitian, Cook Islands Māori, Rapa Nui...) as in fare
- K : most Polynesian languages except Hawaiian, Samoan, Tahitian
- H : most Polynesian languages except Samoan
- WH : NZ Māori (whenua)
- Consonants always separated by one or more vowels (fenua, Haʻapai, ʻolelo)
- Short and long vowels, written either with a macron (āēīōū) or by replication (aa, ee, ii, oo, uu)
- Frequent diphtongs (oiaue, māori)
- Words always end with a vowel
- Loanwords are translitterated (like in Japanese): Sesu Kilisito=Jesus Christ, polokalama=program)
- Frequent English or French loanwords (depending on colonial history)
+.PHONY: all build debug clean profile bench cuobjdump
-Tongan (lea fakatonga)
+CMAKE := cmake
- A E F H I K L M N NG O P S T U V ʻ
- ng (Tonga), h, endings in -onua (fonua)
- article te
- frequent words: 'o, te, ki, mei, i, faka-
- English loanwords
+BUILD_DIR := build
+BENCHMARK_DIR := benchmark_results
-Samoan (gagana samoa)
+all: build
- A E F G I L M N O P S T U V ʻ
- no K letter, uses okina (ʻ) or nothing instead (faka in Tongan is faʻa in Samoan)
- frequent use of L (le)
- frequent words: o, e, le, se, a, i, ma
+build:
+ @mkdir -p $(BUILD_DIR)
+ @cd $(BUILD_DIR) && $(CMAKE) -DCMAKE_BUILD_TYPE=Release ..
+ @$(MAKE) -C $(BUILD_DIR)
-Wallisian (lea faka'uvea)
+debug:
+ @mkdir -p $(BUILD_DIR)
+ @cd $(BUILD_DIR) && $(CMAKE) -DCMAKE_BUILD_TYPE=Debug ..
+ @$(MAKE) -C $(BUILD_DIR)
- A E F G H I K L M N O P S T U V ʻ
- distinguish from Tongan: g instead of ng (tokaga)
- article te
- h is more frequent than s (tahi)
- frequent words: ko, te, ki, mai, i, o, ne'e, e, mo, faka-
- French loanwords
+clean:
+ @rm -rf $(BUILD_DIR)
-East Futunan (lea fakafutuna)
+FUNCTION := $$(cuobjdump -symbols build/sgemm | grep -i Warptiling | awk '{print $$NF}')
- A E F G H I K L M N O P S T U V ʻ
- article le
- frequent words: ko, le, ki, mei, i, o, mo, faka-
- distinguish from Wallisian: S is more frequent than H (tasi)
- distinguish from Samoan: letter K
- French loanwords
+cuobjdump: build
+ @cuobjdump -arch sm_86 -sass -fun $(FUNCTION) build/sgemm | c++filt > build/cuobjdump.sass
+ @cuobjdump -arch sm_86 -ptx -fun $(FUNCTION) build/sgemm | c++filt > build/cuobjdump.ptx
-Turkic languages
+# Usage: make profile KERNEL= PREFIX=
+profile: build
+ @ncu --set full --export $(BENCHMARK_DIR)/$(PREFIX)kernel_$(KERNEL) --force-overwrite $(BUILD_DIR)/sgemm $(KERNEL)
-Note that some Turkic languages like Azeri and Turkmen use a similar Latin alphabet (often Jaŋalif) and similar words, and might be confused with Turkish. Azeri has the letters Əə, Xx and Qq not present in the Turkish alphabet, and Türkmen has Ää, Žž, Ňň, Ýý and Ww. Latin Characters uniquely (or nearly uniquely) used for Turkic languages: Əə, Ŋŋ, Ɵɵ, Ьь, Ƣƣ, Ğğ, İ, and ı. All Turkic languages can form long words by adding multiple suffixes.
-Turkish (Türkçe/Türkiye_Türkçesi)
-Turkish Alphabet
+bench: build
+ @bash gen_benchmark_results.sh
-Lowercase: a b c ç d e f g ğ h ı i j k l m n o ö p r s ş t u ü v y z
-Uppercase: A B C Ç D E F G Ğ H I İ J K L M N O Ö P R S Ş T U Ü V Y Z
-Common words
+[-0.01, 3.00, 3.01, -2.04, -1.02, -3.02, 0.02, 0.02, 4.02, 4.03, -3.01, -3.04, 0.02, 4.01, 4.02, -4.01, -3.03, 1.01, -4.00, -1.04, -0.02, 3.03, -0.03, -1.04, 3.04, 2.03, 3.03, -1.04, -3.01, -3.04, 4.01, -2.01, 3.02, 2.03, -3.03, 1.00, 0.03, -1.01, -2.00, 4.03, -3.04, 2.02, 1.00, -3.04, 2.02, 2.03, 0.00, -4.02, -3.01, -4.02, -2.03, 1.00, 1.03, -3.01, -2.03, 0.00, 3.03, -4.02, 1.02, -1.02, 4.01, 1.02, 3.00, 1.03, 4.01, -0.03, 1.03, -2.02, -1.01, 2.02, -3.01, -0.04, 4.02, 2.04, -3.03, -2.00, 2.01, 4.04, 1.02, -0.01, 3.00, -2.02, -3.04, 1.03, -3.01, 3.03, -2.03, -4.02, 0.03, 0.00, -4.03, -4.00, -1.00, 2.02, 3.02, -4.01, -0.00, 0.01, 1.03, 4.03, 4.00, -0.04, 4.02, -2.04, 0.02, -2.03, 0.04, -2.01, 2.03, -3.02, 4.03, 3.04, 3.00, -1.03, -0.03, -4.03, -4.00, 4.02, 2.02, -4.00, -4.04, 4.04, -0.00, 1.01, -3.03, -0.03, 1.04, -2.01, -0.00, 3.04, 1.03, 2.04, 4.04, -1.02, 2.03, 0.03, 1.01, -4.04, 1.01, -1.02, -2.03, 3.00, 0.04, -0.00, -0.04, -1.04, 0.02, 3.01, -4.03, 0.01, 3.03, 0.01, 1.03, 3.00, -3.00, 1.04, 0.04, -2.04, -1.00, 0.02, 0.01, -2.01, -4.02, 4.02, -2.01, 2.04, -1.01, 2.03, 2.01, 0.02, 1.02, 4.01, 2.00, 1.02, 3.04, -1.01, -2.04, 3.02, 1.01, 0.04, 1.00, -3.04, 3.03, -2.00, 3.00, -3.01, 4.01, 3.01, 1.02, 0.02, 3.00, -1.00, 4.03, -0.02, 1.03, 1.01, 4.02, 4.02, 1.01, 0.01, 4.04, 2.02, 4.01, 4.04, -1.02, 3.03, 4.04, 3.04, -1.00, -1.02, -3.02, 2.01, -0.02, -1.01, 4.02, 0.03, 4.04, -2.03, -2.04, -2.02, -4.00, -3.03, -0.00, -0.03, 4.02, 2.04, -3.00, 2.04, -1.02, 0.01, -0.00, 3.04, -4.01, -2.01, 2.02, -4.01, 3.01, -2.03, 4.04, 3.01, -4.02, -2.00, -4.01, 3.03, -0.01, 2.02, -4.00, 3.03, 1.04, 2.02, -3.03, 2.01, 2.02, -0.02, -4.02, -2.00;
+-1.04, -1.04, -2.00, -0.04, -1.00, -0.04, 0.04, -2.04, -2.04, -2.01, 2.00, 1.01, -4.03, 4.00, -0.02, -3.02, 1.04, -4.01, -1.00, -1.04, 4.03, -2.00, 3.04, -2.00, 1.00, 1.01, 1.02, -2.04, 1.00, 2.03, 0.03, 1.02, 3.00, -3.03, 0.01, -0.04, -3.03, -1.00, 3.03, -2.03, 0.03, 2.02, -4.00, -0.00, 3.00, 2.02, -3.03, -2.04, -2.04, -3.01, 1.04, -2.01, -2.01, 0.03, 1.04, 4.03, 2.01, 0.01, 4.03, 0.03, -4.04, -4.03, -4.00, -0.03, -0.01, 4.00, -2.00, 2.00, 3.01, 0.01, -4.00, -2.02, 2.01, 1.03, -4.03, -1.04, -3.02, 2.01, 3.01, 0.01, -1.01, -1.03, -3.02, -4.04, 2.03, 1.02, 1.02, -0.01, -2.02, 4.02, -4.03, -1.01, 1.00, -3.01, -4.01, 4.02, 2.03, 2.01, -0.03, -4.04, 1.00, -3.02, -2.03, 0.03, -3.03, -1.04, -3.01, -2.00, -3.02, -1.01, -2.02, 0.02, -2.01, 4.02, -2.00, -3.01, 4.04, 3.01, 1.02, -2.03, -2.02, -2.02, 2.02, 4.01, 2.00, -3.03, -1.04, -4.03, 0.01, -0.03, -3.00, 4.00, -4.02, -0.01, 4.01, -2.04, 1.03, -3.02, -4.00, -2.00, 4.04, -0.03, 3.02, -1.02, -1.03, -2.01, -0.04, -0.02, 3.02, 0.04, -0.03, 2.00, 0.04, 4.02, -4.03, -0.02, -1.00, -4.00, -2.01, -3.01, 2.01, -4.03, 4.00, 0.02, -1.01, 1.04, 3.00, -0.01, -1.04, 4.04, -3.01, 1.03, 2.02, 1.04, -2.01, -1.04, -2.02, -4.04, -0.00, -0.01, -0.00, -1.01, 0.03, 2.02, 1.04, -4.00, -0.04, 2.03, -2.03, -1.00, -1.02, -3.03, -0.01, -1.03, -2.02, 3.03, -1.03, -3.00, -2.02, 1.00, 0.02, 0.00, 2.01, 0.02, -1.01, -4.02, -1.03, 0.01, -3.00, -3.02, 3.04, -3.04, 0.04, -4.04, -4.02, 1.01, -1.00, -2.02, -3.02, -3.00, -4.01, 2.04, 3.01, 4.01, 2.00, 2.02, 1.00, -3.04, -0.04, -0.03, 2.02, 0.02, -3.00, 4.01, -2.04, 4.03, 2.04, -0.04, -3.00, 0.00, -3.00, -2.00, -3.03, 0.00, 3.04, -3.03, -1.02, -1.02, -0.00, 1.03, 0.01, 2.01, -4.01, -0.01, 4.01, 4.04;
+ 2.02, -3.03, 2.01, -3.02, -2.03, -0.02, -1.01, 3.03, 1.04, -4.00, 2.04, -0.03, 1.00, 4.01, 2.03, -4.00, -2.04, 0.04, 2.00, -4.01, 0.04, -4.01, -1.04, 1.00, 0.02, 0.04, -3.03, -3.03, -1.02, -3.04, 0.04, 4.03, 3.01, 3.04, -0.02, -1.02, 1.02, -3.01, 3.04, 3.02, 2.04, 0.04, -2.02, -3.02, -1.03, 4.01, -1.02, 1.02, -2.00, 0.00, -2.03, -0.03, -2.00, 1.00, -1.04, -0.03, 1.02, -4.03, -1.02, -1.04, -1.03, -0.04, 3.01, 2.04, 2.02, -2.02, -3.03, 1.00, 1.01, -3.04, -3.02, 3.02, 4.02, -1.00, 0.02, 0.00, -1.00, -2.02, -3.00, 3.01, 3.04, 2.02, -4.02, -3.00, 4.02, 2.02, 2.00, -3.04, 4.04, -1.03, -0.01, 1.03, 1.00, 4.00, 2.04, 3.03, -2.01, 0.01, -2.01, 2.04, 0.01, -0.02, -4.01, 0.00, 0.03, -2.03, 1.00, 4.03, -2.02, 0.01, 0.04, -1.04, 1.00, 2.02, -4.02, -3.04, -0.00, 0.01, -3.04, 1.04, -0.01, 0.03, -0.01, 1.00, -0.00, 1.00, -3.02, -0.04, -4.02, 0.03, -3.00, -0.01, 3.01, -3.00, -3.00, 2.03, -0.01, 0.03, 0.02, -0.03, -2.03, -3.04, 4.04, -3.03, 2.03, -4.01, 2.01, 3.02, -2.04, 1.01, -4.03, 4.01, -0.02, 2.02, -4.02, 3.03, -3.00, 0.00, 0.00, -4.01, 4.02, 4.01, 3.01, 1.01, 0.00, 2.00, 0.04, -1.01, 0.01, -4.02, -0.03, -0.02, 3.00, -2.04, 2.04, -1.01, 3.01, -0.02, 2.04, -4.04, -1.04, -1.01, -0.01, 0.04, 0.03, 0.00, 0.00, 2.00, -4.04, -0.00, -0.02, 3.00, 1.00, 2.02, 1.02, -2.02, -3.00, -3.02, 2.03, 0.00, 0.00, -4.01, -4.04, 3.03, -4.00, 1.02, -4.00, -3.03, -0.00, -1.03, 4.03, -0.02, -3.03, 1.02, 1.03, -4.04, 1.04, 3.04, -4.04, -3.02, 0.04, -3.01, 0.04, 0.02, -1.04, 1.03, 1.04, 1.04, 3.03, 1.03, -4.04, 0.04, 3.04, 2.02, -2.03, 4.04, -0.00, -4.03, -3.02, -4.00, -4.02, 1.02, -1.03, 0.00, -3.02, -1.04, 3.04, 2.00, 4.04, -0.00, -4.04, 4.02, 3.03, 3.00, 1.00, 1.01;
+ 3.02, -1.04, 2.00, 4.00, -1.01, 1.00, -0.00, 2.01, -4.04, -2.02, -0.01, -3.04, 4.03, -4.02, -1.00, -2.01, -0.01, 3.00, 3.01, -4.04, -3.01, -4.01, -1.01, -1.00, 1.02, -3.01, 2.04, -1.04, 4.03, -2.04, 3.02, 4.01, -2.02, -0.00, -0.04, 3.02, -2.01, -4.02, -2.03, 2.03, -2.03, -4.03, -4.02, 3.03, 4.00, -2.03, 4.00, 2.02, -4.04, 0.03, 1.03, -2.02, 0.03, -1.01, -1.02, 0.04, -3.00, 2.02, 0.02, 4.04, -3.02, -1.04, 0.02, -0.00, 0.01, -3.03, 4.01, 2.00, 3.00, -3.02, 0.00, -4.03, -1.04, -2.01, -0.02, -1.02, 4.01, 2.00, 4.03, 1.03, 1.04, 4.03, 4.01, 2.03, 1.04, -2.02, -2.01, 4.00, -0.02, 0.03, 2.04, -1.01, 4.00, -1.04, 2.02, -1.00, -3.02, 2.01, 2.03, -1.00, -0.04, -3.01, -3.00, 2.04, -2.03, 1.04, -0.04, 2.02, -4.04, 4.00, -1.02, -0.02, 3.00, -0.03, 2.00, 3.04, -4.04, 2.01, -0.02, 2.01, -2.03, 1.00, 3.01, 0.01, -2.00, 3.00, 1.04, 4.01, -0.02, 4.01, 3.03, 4.01, 2.04, -3.00, -2.04, -2.04, -2.01, 4.02, 3.02, 0.04, -4.04, 2.00, 1.02, -3.03, 2.00, 3.04, 4.04, 0.00, 3.03, 1.01, 4.00, -0.04, 2.03, 3.01, -2.03, 4.01, 3.01, 3.01, 0.01, 4.03, 4.04, -3.04, 4.01, -0.02, -4.04, -3.00, 1.04, -3.02, -2.00, 1.04, 2.00, -2.03, -2.03, -2.00, -2.02, -4.00, 0.01, 2.01, 0.00, -4.01, -4.03, 3.03, 3.02, -2.00, 3.04, 3.03, -1.00, -2.02, 3.02, -1.02, -3.03, 1.03, -4.03, -2.01, 0.04, -1.00, -1.01, 0.00, -4.01, -4.02, 2.03, 3.04, -0.00, -4.02, -3.04, -3.00, 1.04, -4.04, -0.03, 1.04, 0.01, 3.02, 0.04, 3.00, 2.03, -3.03, -3.04, -2.00, -3.03, 0.04, -3.01, 3.04, 0.02, 3.00, -4.03, -0.03, -4.01, 1.00, -3.03, -2.00, 3.04, -0.04, 1.01, 3.04, -0.04, -2.01, -2.00, -1.02, 3.02, -2.04, -3.04, -3.02, -1.03, -2.04, 0.04, 3.02, 1.01, 3.00, 3.03, -2.02, -3.00, 0.00, 3.02, 2.01, 1.03, 4.03;
- bir — one, a
- bu — this
- ancak — but
- oldu — was (happened)
- şu — that
+cmake_minimum_required(VERSION 3.19)
+project(NVIDIA_SGEMM_PRACTICE LANGUAGES CXX CUDA)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-Misc.
+find_package(CUDA REQUIRED)
- The letter "j" is only used in loanwords.
- Words never begin with "ğ"
- Look for common word endings. Tense changes in Turkish verbs are created by adding suffixes to the end of the verb. Pluralizations occur by adding -lar and -ler.
- Common Tense Changes: -yor -mış -muş -sun
- Possessivity/person: -im -un -ın -in -iz -dur -tır
- Example: Yaptı , "[He] did it"; Yap is the verb stem meaning "to do", -mış indicates the perfect tense, -tır indicates the third person (he/she/it).
- Example: Adalar, "Islands"; Ada is a noun meaning "island", -lar makes it plural.)
- Example: Evimiz, "Our house"; Ev is a noun meaning "house", -im indicates the first-person possessor, which -iz then makes plural.)
+# ensure cuda is available
+include(CheckLanguage)
+check_language(CUDA)
-Azeri (Azərbaycanca)
+set(CMAKE_CXX_STANDARD 20)
+set(CUDA_COMPUTE_CAPABILITY 86)
-Azeri can be easily recognized by the frequent use of ə. This letter is not used in any other officially recognized modern Latin alphabet. In addition, it uses the letters x and q, which are not used in Turkish.
+# in debug mode, add debug symbols to device code
+# this disables most optimizations and kills performance
+add_compile_options("$<$,$>:-G;-src-in-ptx>")
+# add_compile_options("--ptxas-options=-v")
- Common words: və, ki, ilə, bu, o, isə, görə, da, də
- Frequent use of diacritics: ç, ğ, ı, İ, ö, ş, ü
- Words ending in -lar, -lər, -ın, -in, -da, -də, -dan, -dən
- Words never beginning with ğ or ı
- Words rarely beginning with two or more consonants
- Transliteration of foreign words and names, e.g. Audrey Hepburn = Odri Hepbern
+# Configure header file search paths
+include_directories(${CUDA_INCLUDE_DIRS})
+include_directories(${PROJECT_SOURCE_DIR}/src)
+# Configure the source file path to be compiled
+aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)
-Chinese (中文)
+# generate executable
+add_executable(sgemm sgemm.cu ${SRC})
+set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
+target_link_libraries(sgemm ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES})
- No spaces, except between punctuation marks and (sometimes) foreign words.
- Arabic numerals (0-9) sometimes used
- Punctuation:
- Period 。(not .)
- Serial comma 、(distinguished from the regular comma ，)
- Ellipse …… (six dots)
- No hiragana, katakana, or hangul
- May be written vertically
+add_executable(cuBLAS_sgemm cuBLAS_sgemm.cu )
+set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
+target_link_libraries(cuBLAS_sgemm ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES})
-Simplified Chinese (简体) vs Traditional Chinese (繁體)
+add_executable(simplest_kernel simplest_kernel.cu)
+set_target_properties(sgemm PROPERTIES CUDA_ARCHITECTURES ${CUDA_COMPUTE_CAPABILITY})
+target_link_libraries(simplest_kernel ${CUDA_LIBRARIES})
-Note: Many characters were not simplified. As a result, it is common for a short word or phrase to be identical between Simplified and Traditional, but it is rare for an entire sentence to be identical as well.
+import gzip
+import random
+import tqdm
+import numpy as np
-Common radicals different between Traditional and Simplified:
+import torch
+from torch.optim import Adam
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, Dataset
- Simplified: 讠钅饣纟门(e.g. 语 银 饭 纪 问)
- Traditional: 訁釒飠糹門(e.g. 語 銀 飯 紀 問)
+from simple_hierarchical_transformer import HierarchicalTransformer
-Common characters different between Traditional and Simplified:
+# constants
- Simplified: 国 会 这 来 对 开 关 门 时 个 书 长 万 边 东 车 爱 儿
- Traditional: 國 會 這 來 對 開 關 門 時 個 書 長 萬 邊 東 車 愛 兒
+NUM_BATCHES = int(1e5)
+BATCH_SIZE = 2
+GRADIENT_ACCUMULATE_EVERY = 8
+LEARNING_RATE = 1e-4
+VALIDATE_EVERY = 100
+PRIME_LENGTH = 128
+GENERATE_EVERY = 500
+SEQ_LEN = 8192
+GENERATE_LENGTH = 1024
-Standard written Chinese (based on Mandarin) vs written Vernacular Cantonese
-See also: zh:粵語
+# helpers
-Note: Apart from Hong Kong, there are also Cantonese-speakers in southern Mainland China, Malaysia and Singapore[1], so written Cantonese can be written in either Simplified or Traditional characters.
+def cycle(loader):
+ while True:
+ for data in loader:
+ yield data
+def decode_token(token):
+ return str(chr(max(32, token)))
-Common characters in Vernacular Cantonese that do not occur or seldom occur in Mandarin:
+def decode_tokens(tokens):
+ return "".join(list(map(decode_token, tokens)))
- 嘅 咗 咁 嚟 啲 唔 佢 乜 嘢 嗰 冇 睇
+# instantiate transformer
-Some of the above characters are not supported in all character encodings, so sometimes the 口 radical on the left is substituted with a 0 or o, e.g.
+model = HierarchicalTransformer(
+ num_tokens = 256,
+ dim = 1024,
+ depth = 8,
+ seq_len = SEQ_LEN,
+ use_flash_attn = True,
+ compress_factor = 32
+).cuda()
- o既 0既
+# prepare enwik8 data
+with gzip.open("./data/enwik8.gz") as file:
+ data = np.frombuffer(file.read(int(95e6)), dtype=np.uint8).copy()
+ np_train, np_valid = np.split(data, [int(90e6)])
+ data_train, data_val = torch.from_numpy(np_train), torch.from_numpy(np_valid)
-Sometimes, different Chinese characters are used to express the same meaning in Cantonese and Mandarin. If you use the one commonly used in Cantonese to express the same meaning when you are speaking or writing Mandarin, a native speaker may be confused or even find it difficult to understand, and vice versa. Some examples are: (Cantonese vs Mandarin)
+class TextSamplerDataset(Dataset):
+ def __init__(self, data, seq_len):
+ super().__init__()
+ self.data = data
+ self.seq_len = seq_len
- 食vs吃(eat) 飲vs喝(drink) 企vs站(stand) 凍vs冷(cold) 落vs下(down) 著vs穿(wear) 讀vs唸(read) 鬧vs罵(scold) 計vs算(calculate) 咪vs別(do not) 行vs走(walk/go) 先vs才(then)
+ def __getitem__(self, index):
+ rand_start = torch.randint(0, self.data.size(0) - self.seq_len, (1,))
+ full_seq = self.data[rand_start : rand_start + self.seq_len + 1].long()
+ return full_seq.cuda()
+ def __len__(self):
+ return self.data.size(0) // self.seq_len
-There are Chinese words used to construct vocabularies used in Cantonese that are not or seldomly implemented in modern Mandarin. Some examples are: (Cantonese vs Mandarin)
+train_dataset = TextSamplerDataset(data_train, SEQ_LEN)
+val_dataset = TextSamplerDataset(data_val, SEQ_LEN)
+train_loader = cycle(DataLoader(train_dataset, batch_size=BATCH_SIZE))
+val_loader = cycle(DataLoader(val_dataset, batch_size=BATCH_SIZE))
- 成日vs整天(always) 傾計vs聊天(talk) 返工vs上班(go to work) 溫書vs溫習(study) 影片vs視頻(video) 隔離vs旁邊(nearby) 起屋vs蓋樓(build a house) 聽日vs明天(tomorrow) 巴閉vs囂張(arrogant) 搞掂vs完成(finished) 定係vs還是(or) 靚仔vs帥哥(handsome male) 鍾意vs喜歡(like) 犀利vs厲害(powerful) 同埋vs和/及(and) 黐綫vs瘋的(crazy) 雪櫃vs冰箱(fridge)
+# optimizer
+optim = Adam(model.parameters(), lr = LEARNING_RATE)
-Cantonese vocabularies constructed by Cantonese words are used in daily life in southern China and are not used in modern Mandarin. Some examples are:
+# training
- 咪咁(don't be like this) 好冇(ok?) 玩嘢(to play tricks) 做嘢(to work) 睇戲(to watch a film/movie) 唔知(don't know) 埋嚟(come) 嗰個(that) 咁嘅嘢(such thing) 佢哋(they) 咩事/乜事(what?) 冇嘢(nothing) 嗰陣(at that moment) 越嚟越多(more and more) 我嘅(mine) 梗係(of course) 𥄫(to peek) 冧佢(love him/her) 拎畀我(take it to me) 嘥曬(everything is wasted) 你啱(you are right) 𢫏住(to cover something) 冚唪唥(all) 撳實(to press something tightly) 瞓覺(to sleep) 掟石仔(to throw a tiny stone) 唓[a modal word to express comtemption] 噃[a modal word for reminding or warning someone] 詏交(to argue) 好嬲(very angry) 心悒(feeling depressed in heart) 𧨾女仔(to please a girl) 得咁多咋(only this much) 做好咗(done something well)
+for i in tqdm.tqdm(range(NUM_BATCHES), mininterval = 10.0, desc = "training"):
+ model.train()
+ for _ in range(GRADIENT_ACCUMULATE_EVERY):
+ loss, (ce_loss, recon_loss) = model(next(train_loader), return_loss = True)
+ loss.backward(loss / GRADIENT_ACCUMULATE_EVERY)
-Finally, when terms are introduced from other countries(especially the US and the UK) to China, Cantonese and Mandarin often get different translations, where Cantonese often translates according to pronunciation of the terms in English and Mandarin often translates according to the meaning of the terms. Some examples are: (Cantonese vs Mandarin)
+ print(f"training loss: {ce_loss.item()}")
+ torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
- 的士(dik1 si2, has no direct meaning, translated according to the English pronunciation.) vs 出租車(chū zū chē, meaning cars for renting.), translated from Taxi.
- 巴士(baa1 si2, has no direct meaning, translated according to the English pronunciation.) vs 公車(gōng chē, meaning public cars.), translated from Bus.
- 多士(do1 si2, has no direct meaning, translated according to the English pronunciation.) vs 土司(tǔ sī, has no direct meaning, translated according to the English pronunciation.), translated from Toast.
- 騷(sou1, has no direct meaning, translated according to the English pronunciation.) vs 秀(xìu, has no direct meaning, translated according to the English pronunciation), translated from Show.
- 士多(si2 do1, has no direct meaning, translated according to the English pronunciation) vs 小店(xiǎo diàn, meaning small shop), translated from Store.
- 𨋢(lip1, has no direct meaning, translated according to the English pronunciation) vs 升降機(shēng jiàng jī, meaning machine that elevates and lowers itself), translated from Lift/Elevator.
- 掰拜(baai1 baai3, has no direct meaning, translated according to the English pronunciation) vs 再見(zài jiàn, meaning see you again), translated from Byebye/Goodbye.
+ optim.step()
+ optim.zero_grad()
-Japanese (日本語)
+ if i % VALIDATE_EVERY == 0:
+ model.eval()
+ with torch.no_grad():
+ loss, (ce_loss, recon_loss) = model(next(val_loader), return_loss = True)
+ print(f"validation loss: {ce_loss.item()}")
- Katakana (カタカナ) and hiragana (ひらがな) characters mixed with kanji (漢字)
- No spaces
- Number system = Arabic Numerals (1,2,3 etc.)
- Punctuation:
- Period 。
- Comma 、(，also used in double byte)
- Quotation marks 「」
- Occasional small characters beside large ones, eg. しゃ りゅ しょ って シャ リュ ショ ッテ
- Double tick marks (known as daku-on) appearing at upper right of characters, eg. で が ず デ ガ ズ
- Empty circles (known as handaku-on) appearing at upper right of characters, eg. ぱ ぴ パ ぴ
- Frequent characters: の を は が
- Originally written vertically(books, school, etc.) but mostly appears horizontal online.
+ if i % GENERATE_EVERY == 0:
+ model.eval()
+ inp = random.choice(val_dataset)[:PRIME_LENGTH]
+ prime = decode_tokens(inp)
+ print(f"%s \n\n %s", (prime, "*" * 100))
-Korean (한국어/조선말)
+ sample = model.generate(inp[None, ...], GENERATE_LENGTH)
+ output_str = decode_tokens(sample[0])
+ print(output_str, "\n")
- Western-style punctuation marks
- Western-style spacing
- Hangul letters(phonetic) ex: ㅂ(b in book) ㅈ(j in jump) ㅅ(s in sock)ㅊ(ch in champion) ㅍ(p in pox)
- Hangul letters used to form syllable blocks; e.g. ㅅ s + ㅓ o + ㅇ ng = 성 song
- Circles and ellipses are commonplace in Hangul; are exceedingly rare in Chinese.
- General appearance has relatively-uniform complexity, as contrasted with Chinese or Japanese.
-Khmer language ភាសារខ្មែរ
+{
+ "version": "1.0",
+ "truncation": null,
+ "padding": null,
+ "added_tokens": [
+ {
+ "id": 0,
+ "content": "",
+ "single_word": false,
+ "lstrip": false,
+ "rstrip": false,
+ "normalized": true,
+ "special": true
+ },
+ {
+ "id": 1,
+ "content": "",
+ "single_word": false,
+ "lstrip": false,
+ "rstrip": false,
+ "normalized": true,
+ "special": true
+ },
+ {
+ "id": 2,
+ "content": "",
+ "single_word": false,
+ "lstrip": false,
+ "rstrip": false,
+ "normalized": true,
+ "special": true
+ }
+ ],
+ "normalizer": {
+ "type": "Sequence",
+ "normalizers": [
+ {
+ "type": "Prepend",
+ "prepend": "▁"
+ },
+ {
+ "type": "Replace",
+ "pattern": {
+ "String": " "
+ },
+ "content": "▁"
+ }
+ ]
+ },
+ "pre_tokenizer": null,
+ "post_processor": {
+ "type": "TemplateProcessing",
+ "single": [
+ {
+ "SpecialToken": {
+ "id": "",
+ "type_id": 0
+ }
+ },
+ {
+ "Sequence": {
+ "id": "A",
+ "type_id": 0
+ }
+ }
+ ],
+ "pair": [
+ {
+ "SpecialToken": {
+ "id": "",
+ "type_id": 0
+ }
+ },
+ {
+ "Sequence": {
+ "id": "A",
+ "type_id": 0
+ }
+ },
+ {
+ "SpecialToken": {
+ "id": "",
+ "type_id": 1
+ }
+ },
+ {
+ "Sequence": {
+ "id": "B",
+ "type_id": 1
+ }
+ }
+ ],
+ "special_tokens": {
+ "": {
+ "id": "",
+ "ids": [
+ 1
+ ],
+ "tokens": [
+ ""
+ ]
+ }
+ }
+ },
+ "decoder": {
+ "type": "Sequence",
+ "decoders": [
+ {
+ "type": "Replace",
+ "pattern": {
+ "String": "▁"
+ },
+ "content": " "
+ },
+ {
+ "type": "ByteFallback"
+ },
+ {
+ "type": "Fuse"
+ },
+ {
+ "type": "Strip",
+ "content": " ",
+ "start": 1,
+ "stop": 0
+ }
+ ]
+ }
+}
-Khmer is written using the distinctive Khmer alphabet.
+#include "q_gemm.cuh"
+#include "util.cuh"
+#include "matrix_view.cuh"
+#include "../config.h"
+
+// #include
+// #include
+
+#define BLOCK_KN_SIZE 512
+#define MAX_GROUPS_IN_BLOCK (BLOCK_KN_SIZE / 32)
+#define MAX_COUNT_M 2
+#define CLEAR_N_SIZE 256
+//#define DEBUG
+
+#include "q_gemm_dq.cuh"
+
+typedef void (*fp_gemm_half_q_half_kernel)
+(
+ const half*,
+ const uint32_t*,
+ const uint32_t*,
+ const half*,
+ const uint16_t*,
+ half*,
+ const int,
+ const int,
+ const int,
+ const int,
+ const int,
+ const uint16_t*,
+ const int,
+ const int,
+ const int,
+ const int,
+ const int,
+ const int
+);
+
+template
+__global__ void gemm_half_q_half_kernel
+(
+ const half* a,
+ const uint32_t* b_q_weight,
+ const uint32_t* b_q_scale,
+ const half* b_q_scale_max,
+ const uint16_t* b_q_groups,
+ half* c,
+ const int size_m,
+ const int size_n,
+ const int size_k,
+ const int groups,
+ const int groupsize,
+ const uint16_t* __restrict__ b_q_perm,
+ const int rows_8,
+ const int rows_6,
+ const int rows_5,
+ const int rows_4,
+ const int rows_3,
+ const int rows_2
+)
+{
+ MatrixView_half a_(a, size_m, size_k);
+ MatrixView_half_rw c_(c, size_m, size_n);
+ MatrixView_q4_row b_q_scale_(b_q_scale, groups, size_n);
- rarely uses spaces
- Letters have a distinctively "taller" shape than other Brahmic scripts.
- Uses Khmer numerals in writing ១ ២ ៣ ៤ ៥ ៦ ៧ ៨ ៩.
- Has smaller version of consonants placed below main consonants that may appear clustered
- Has 24 diacritics denoting syllable rhymes - ា ិ ី ឹ ឺ ុ ូ ួ ើ ឿ ៀ េ ែ ៃ េា ៅ ុំ ំ ាំ ះ ុះ េះ ោះ
- Uses this as a full stop: ។
+ int t = threadIdx.x;
-Greek (Ελληνικά)
+ // Block
-Modern Greek is written with Greek alphabet in monotonic, polytonic or atonic, either according to Demotic (Mr. Triantafilidis) grammar or Katharevousa grammar. Some people write in Greeklish (Greek with Latin script) which is either Visual-based, orthographic or phonetic or just messed-up (mixed). The only official orthographic forms of Greek language are Monotonic and Polytonic.
-Normal Modern Greek (Greek Monotonic)
+ int offset_n = blockIdx.x * BLOCK_KN_SIZE;
+ int offset_m = blockIdx.y * m_count;
+ int offset_k = blockIdx.z * BLOCK_KN_SIZE;
- words και, είναι;
- Each multi-syllable word has one accent/tone mark (oxia): ά έ ή ί ό ύ ώ
- The only other diacritic ever used is the tréma: ϊ/ΐ, ϋ/ΰ, etc.
+ int end_n = min(offset_n + BLOCK_KN_SIZE, size_n);
+ int end_m = min(offset_m + m_count, size_m);
+ int end_k = min(offset_k + BLOCK_KN_SIZE, size_k);
+ int n = offset_n + t;
-Pre-1980s Greek (Greek Polytonic)
+ // Preload block_a
-Katharevousa, Dimotiki (Triantafylidis' grammar)
+ __shared__ half block_a[m_count][BLOCK_KN_SIZE];
- Diacritics: ά, ᾶ, ἀ, ἁ, and combinations, also with other vowels.
- Some texts, especially in Katharevousa, also have ὰ, ᾳ, in combination with other diacritics.
+ if (offset_k + t < end_k)
+ {
+ for (int m = 0; m < m_count; ++m)
+ {
+ const half* a_ptr = a_.item_ptr(offset_m + m, 0);
+ half* block_a_ptr = block_a[m];
+ half a0 = a_ptr[b_q_perm[offset_k + t]];
+ block_a_ptr[t] = a0;
+ }
+ }
-Ancient Greek
+ __syncthreads();
- Diacritics: ά, ὰ, ᾶ, ἀ, ἁ, ᾳ, and combinations, also with other vowels; ῥ; tilde (ᾶ) often appears more like a rounded circumflex
- some texts feature lunate sigma (looks like c) instead of σ/ς
+ if (n >= size_n) return;
-Greek Atonic
+// for (int xs_n = 0; xs_n < size_n - BLOCK_KN_SIZE;
- Was common in some Greek media (television);
- You will see Greek characters without accents/tones;
- words: και, ειναι, αυτο.
+ // Advance to subblock
-Greek in Greeklish
+// int sub_offset_k = SUBBLOCK_K_SIZE * threadIdx.y;
+// offset_k += sub_offset_k;
+// end_k = min(offset_k + SUBBLOCK_K_SIZE, size_k);
- Automated conversion software for Greeklish->Greek conversion exists. If you notice a Greeklish text it may be useful for the Greek el.wikipedia (after conversion).
- Keep in mind: in Greeklish more than one character may be used for one letter. (example: th for Θ (theta)).
+// if (threadIdx.y > 0) return;
+// int sub_offset_k = 0;
-Orthographic Greeklish
+ // Find initial group
- words kai, einai.
+ int group = offset_k / groupsize;
-Phonetic Greeklish
+ // Preload scales
- words ke, ine;
- omega appears as o;
- ei, oi appear as i;
- ai appears as e.
+ half scales[MAX_GROUPS_IN_BLOCK];
-Visual-based Greeklish
+ int groups_in_block = DIVIDE((end_k - offset_k), groupsize);
+ for (int g = 0; g < groups_in_block; g++)
+ {
+ half s = dq_scale(b_q_scale_.item(group + g, n), b_q_scale_max[group + g]);
+ scales[g] = s;
+ }
- omega (Ω or ω) may appear as W or w;
- epsilon (E) may appear as 3;
- alpha (A) may appear as 4;
- theta (Θ) may appear as 8;
- upsilon (Y) may appear as \|/;
- gamma (γ) may appear as y
- More than one character may be used for one letter.
+ // Find initial q row
-Messed-up (Mixed) Greeklish
+ int pre_rows_8 = min(rows_8, offset_k);
+ int pre_rows_6 = offset_k > rows_8 ? min(rows_6, offset_k) - rows_8 : 0;
+ int pre_rows_5 = offset_k > rows_6 ? min(rows_5, offset_k) - rows_6 : 0;
+ int pre_rows_4 = offset_k > rows_5 ? min(rows_4, offset_k) - rows_5 : 0;
+ int pre_rows_3 = offset_k > rows_4 ? min(rows_3, offset_k) - rows_4 : 0;
+ int pre_rows_2 = offset_k > rows_3 ? min(rows_2, offset_k) - rows_3 : 0;
+ int qk = 0;
+ qk += pre_rows_8 / 32 * 8;
+ qk += pre_rows_6 / 32 * 6;
+ qk += pre_rows_5 / 32 * 5;
+ qk += pre_rows_4 / 32 * 4;
+ qk += pre_rows_3 / 32 * 3;
+ qk += pre_rows_2 / 32 * 2;
- words kai, eine;
- combines principles of phonetic, visual-based and orthographic Greeklish according to writer's idiosyncrasy;
- The most commonly used form of Greeklish.
+ const uint32_t* b_ptr = b_q_weight + qk * size_n + n;
+ const half* a_ptr = &block_a[0][0];
+ int a_stride = BLOCK_KN_SIZE;
+// const half* a_ptr = a_.item_ptr(offset_m, 0);
+// int a_stride = size_k;
-Armenian (Հայերեն)
+ half qs_h = scales[0];
+ int scales_idx = 0;
+ int nextgroup = offset_k + groupsize;
-Armenian can be recognized by its unique 39-letter alphabet:
+ // Column result
-Ա Բ Գ Դ Ե Զ Է Ը Թ Ժ Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ Մ Յ Ն Շ Ո Չ Պ Ջ Ռ Ս Վ Տ Ր Ց Ւ Փ Ք ԵՎ(և) Օ Ֆ
-Georgian (ქართული)
+ half2 block_c[m_count] = {};
-Georgian can be recognised by its unique alphabet (note some characters have fallen out of use).
+ // Dot product over groups
-ა ბ გ დ ე ვ ზ ჱ თ ი კ ლ მ ნ ჲ ო პ ჟ რ ს ტ ჳ უ ფ ქ ღ ყ შ ჩ ც ძ წ ჭ ხ ჴ ჯ ჰ ჵ ჶ ჷ ჸ
-Cyrillic alphabet
+ int k = offset_k;
-Bolding denotes letters unique to the language
-Slavic languages
-Belarusian (беларуская)
+ while (k < rows_8 && k < end_k)
+ {
+ int end_k_sg = min(min(k + 128, rows_6), end_k);
+ uint32_t q_0[8], q_1[8];
+ load_8(b_ptr, size_n, q_0);
+ qdot_8bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_8bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_8bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_8bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
- uses: ё, і, й, ў, ы, э, ’
- features: шч used instead of щ
- the only Cyrillic language not to feature и.
+ while (k < rows_6 && k < end_k)
+ {
+ int end_k_sg = min(min(k + 128, rows_5), end_k);
+ uint32_t q_0[6], q_1[6];
+ load_6(b_ptr, size_n, q_0);
+ qdot_6bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_6bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_6bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_6bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
-Bulgarian (български)
+ while (k < rows_5 && k < end_k)
+ {
+ int end_k_sg = min(min(k + 128, rows_4), end_k);
+ uint32_t q_0[5], q_1[5];
+ load_5(b_ptr, size_n, q_0);
+ qdot_5bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_5bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_5bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_5bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
- uses: ъ, щ, я, ю, й
- words: със, в
- features: many words end in definite article –ът, –ят, –та, –то, –те
+// while (k + 128 < rows_4 && k + 128 < end_k)
+// {
+// uint32_t q_0[8], q_1[8];
+// load_8(b_ptr, size_n, q_0);
+// load_8(b_ptr, size_n, q_1);
+// qdot_4bit_64(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
+// qdot_4bit_64(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1);
+// }
-Macedonian (македонски)
+ while (k < rows_4 && k < end_k)
+ {
+ int end_k_sg = min(min(k + 128, rows_3), end_k);
+ uint32_t q_0[4], q_1[4];
+ load_4(b_ptr, size_n, q_0);
+ qdot_4bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_4bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_4bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_4bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
- uses: ј, љ, њ, џ, ѓ, ќ, ѕ
- words: во, со
- features: р is usually found between consonants, for example првин
+// while (k + 128 < rows_3 && k + 128 < end_k)
+// {
+// uint32_t q_0[6], q_1[6];
+// load_6(b_ptr, size_n, q_0);
+// load_6(b_ptr, size_n, q_1);
+// qdot_3bit_64(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
+// qdot_3bit_64(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1);
+// }
-Russian (русский)
+ while (k < rows_3 && k < end_k)
+ {
+ int end_k_sg = min(min(k + 128, rows_2), end_k);
+ uint32_t q_0[3], q_1[3];
+ load_3(b_ptr, size_n, q_0);
+ qdot_3bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_3bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_3bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_3bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
- uses: ё, й, ъ (rarely), ы, э, щ
+// while (k + 128 < rows_2 && k + 128 < end_k)
+// {
+// uint32_t q_0[8];
+// load_8(b_ptr, size_n, q_0);
+// qdot_2bit_128(k, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0);
+// }
-Serbian (српски)
+ while (k < rows_2 && k < end_k)
+ {
+ int end_k_sg = min(k + 128, end_k);
+ uint32_t q_0[2], q_1[2];
+ load_2(b_ptr, size_n, q_0);
+ qdot_2bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_2bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ qdot_2bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_0, q_1);
+ qdot_2bit_32(k, end_k_sg, group, nextgroup, groupsize, n, scales, scales_idx, qs_h, block_c, a_ptr, a_stride, b_ptr, size_n, q_1, q_0);
+ }
- uses: ј, љ, њ, џ, ђ, ћ
- does not use: ъ, щ, я, ю, й
- words: је, у
- features: large consonant clusters, for example српски
+ // Accumulate column sums in c
-Ukrainian (українська)
+ for (int m = 0; m < m_count; m++) atomicAdd(c_.item_ptr(offset_m + m, n), __hadd(block_c[m].x, block_c[m].y));
+ //for (int m = 0; m < m_count; m++) c_.set(offset_m + m, n, block_c[m]);
+}
- uses: є, и, і, ї, й, ґ, є щ, ’
- does not use: ъ, ё, ы, э
+fp_gemm_half_q_half_kernel pick_gemm_half_q_half_kernel(bool first_block, const int m_count)
+{
+ if (m_count == 1) return gemm_half_q_half_kernel;
+ if (m_count == 2) return gemm_half_q_half_kernel;
+// if (m_count == 3) return gemm_half_q_half_kernel;
+// if (m_count == 4) return gemm_half_q_half_kernel;
+// if (m_count == 5) return gemm_half_q_half_kernel;
+// if (m_count == 6) return gemm_half_q_half_kernel;
+// if (m_count == 7) return gemm_half_q_half_kernel;
+// if (m_count == 8) return gemm_half_q_half_kernel;
+ return NULL;
+}
-Mongolian
+void gemm_half_q_half_cuda_part
+(
+ const half* a,
+ QMatrix* b,
+ half* c,
+ int size_m,
+ int size_n,
+ int size_k,
+ int count_m
+)
+{
+ dim3 blockDim, gridDim;
+ blockDim.x = BLOCK_KN_SIZE;
+ blockDim.y = 1;
+ blockDim.z = 1;
+ gridDim.x = DIVIDE(size_n, BLOCK_KN_SIZE);
+ gridDim.y = DIVIDE(size_m, count_m);
+ gridDim.z = DIVIDE(size_k, BLOCK_KN_SIZE);
+
+ fp_gemm_half_q_half_kernel kernel = pick_gemm_half_q_half_kernel(true, count_m);
+
+ kernel<<>>
+ (
+ a,
+ b->cuda_q_weight,
+ b->cuda_q_scale,
+ b->cuda_q_scale_max,
+ b->cuda_q_groups,
+ c,
+ size_m,
+ size_n,
+ size_k,
+ b->groups,
+ b->groupsize,
+ b->cuda_q_perm,
+ b->rows_8,
+ b->rows_6,
+ b->rows_5,
+ b->rows_4,
+ b->rows_3,
+ b->rows_2
+ );
+}
- uses: ө, ү
- does not use: ё, й, к, щ, ъ, ы, ь, ю, я
- used only in names or borrowed words: в, е, з, ф, ц
+void gemm_half_q_half_cuda
+(
+ cublasHandle_t cublas_handle,
+ const half* a,
+ QMatrix* b,
+ half* c,
+ int size_m,
+ int size_n,
+ int size_k,
+ bool clear,
+ half* temp_dq
+)
+{
+ if (size_m >= MAX_Q_GEMM_ROWS)
+ {
+ // Reconstruct FP16 matrix, then cuBLAS
+
+ //DBGI3(size_m, size_n, size_k);
+
+ if (!temp_dq) temp_dq = b->temp_dq;
+ b->reconstruct(temp_dq);
+
+ cublasSetMathMode(cublas_handle, CUBLAS_TENSOR_OP_MATH);
+
+ //DBGI3(size_m, size_n, size_k);
+
+ const half alpha = __float2half(1.0f);
+ const half beta = clear ? __float2half(0.0f) : __float2half(1.0f);
+ cublasHgemm(cublas_handle,
+ CUBLAS_OP_N,
+ CUBLAS_OP_N,
+ size_n,
+ size_m,
+ size_k,
+ &alpha,
+ temp_dq,
+ size_n,
+ a,
+ size_k,
+ &beta,
+ c,
+ size_n);
+
+// const float alpha = 1.0f;
+// const float beta = clear ? 0.0f : 1.0f;
+// cublasSgemmEx(cublas_handle,
+// CUBLAS_OP_N,
+// CUBLAS_OP_N,
+// size_n,
+// size_m,
+// size_k,
+// &alpha,
+// temp_dq,
+// CUDA_R_16F,
+// size_n,
+// a,
+// CUDA_R_16F,
+// size_k,
+// &beta,
+// c,
+// CUDA_R_16F,
+// size_n);
+ }
+ else
+ {
+ // Quantized matmul
-Montenegrin
+ if (clear) clear_tensor_cuda(c, size_m, size_n);
- uses: З́, С́
+ int max_chunks = size_m / MAX_COUNT_M;
+ int last_chunk = max_chunks * MAX_COUNT_M;
+ int last_chunk_size = size_m - last_chunk;
-Ossetian
+ // DBGI3(size_m, size_n, size_k);
+ // DBGI3(max_chunks, last_chunk, last_chunk_size);
- uses: ӕ
+ if (max_chunks)
+ gemm_half_q_half_cuda_part(a, b, c, last_chunk, size_n, size_k, MAX_COUNT_M);
-Arabic alphabet
+ if (last_chunk_size)
+ gemm_half_q_half_cuda_part(a + last_chunk * size_k, b, c + last_chunk * size_n, last_chunk_size, size_n, size_k, last_chunk_size);
+ }
+}
- All languages using the Arabic alphabet are written right-to-left.
- A number of other languages have been written in the Arabic alphabet in the past, but now are more commonly written in Latin characters; examples include Turkish, Somali and Swahili.
+__global__ void clear_kernel
+(
+ half* __restrict__ c,
+ const int size_m,
+ const int size_n
+)
+{
+ int m = blockIdx.y;
+ int n = (blockIdx.x * CLEAR_N_SIZE + threadIdx.x) * 8;
+ if (n >= size_n) return;
+ int4* c_ptr = (int4*)(c + m * size_n + n);
+ *c_ptr = {};
+}
-Arabic (العربية)
+void clear_tensor_cuda
+(
+ half* c,
+ int size_m,
+ int size_n
+)
+{
+ dim3 blockDim, gridDim;
+ blockDim.x = CLEAR_N_SIZE;
+ blockDim.y = 1;
+ gridDim.x = DIVIDE(size_n / 8, CLEAR_N_SIZE);
+ gridDim.y = size_m;
+ clear_kernel<<>>(c, size_m, size_n);
+}
- backwards question mark: ؟
- short vowels are not written, so many words are written with no vowel at all
- common prefix: -الـ
- common suffix: ـة-
- words: إلى، من، على
+#!/usr/bin/env python3
+import argparse
+
+import torch
+import torch.nn as nn
+from datasets import load_dataset
+from gptq_triton import load_quant
+from tqdm import tqdm
+from transformers import AutoTokenizer, LlamaForCausalLM
-Persian (فارسی)
-Except in very rare case, verbs are at the end of a phrase.
+parser = argparse.ArgumentParser()
+
+parser.add_argument('--model', type=str, help='Path to model, either a HuggingFace model or a quantized model')
+parser.add_argument('--quant', action='store_true', help='Whether the model is quantized')
+parser.add_argument('--stride', type=int, default=512, help='Stride for calculating perplexity')
+parser.add_argument('--context-length', type=int, default=2048, help='Length of context to use')
+
+
+def main():
+ args = parser.parse_args()
- common verbs: کرد، بود، شد، است، میشود
- uses: پ، چ، ژ، گ
- words: که، به
+ if not args.quant:
+ model = get_llama(args.model)
+ model.eval()
+ model.to('cuda')
+ else:
+ model = load_quant(args.model)
+ model.eval()
+ model.to('cuda')
-Urdu (اردو)
+ # NOTE: Setting use_fast=False for now, as the alternative was an order of magnitude slower on a recent `transformers` commit
+ tokenizer = AutoTokenizer.from_pretrained(args.model, use_fast=False)
+ context_length = model.seqlen if args.context_length is None else args.context_length
- uses: ٹ، ڈ، ڑ، ں، ے
- many words ending in ے
- words: اور، ہے
- to distinguish from Arabic: in many texts, Urdu is written stylistically with words ‘slanting’ downwards from top-right to bottom-left (unlike the ‘linear’ style of Arabic, Persian etc.).
+ for dataset in ['wikitext-2', 'ptb', 'c4']:
+ ppl = calculate_perplexity(model, tokenizer, dataset, max_length=context_length, stride=args.stride)
+ print(f"{dataset} perplexity: {ppl}")
+
+
+def get_llama(model: str):
+ """
+ Load a pretrained Llama model
+ """
+ def skip(*args, **kwargs):
+ pass
+ # NOTE: This is a nasty hack, but it speeds up model building by a huge amount
+ old_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
+ torch.nn.init.kaiming_uniform_ = skip
+ torch.nn.init.uniform_ = skip
+ torch.nn.init.normal_ = skip
+
+ model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
+ model.seqlen = 2048
+
+ # Restore the old initializers
+ torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = old_inits
+
+ return model
+
+
+def get_dataset(dataset_name: str, tokenizer) -> torch.Tensor:
+ if dataset_name == "wikitext-2":
+ test = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")
+ encodings = tokenizer("\n\n".join(test["text"]), return_tensors="pt").input_ids
+ elif dataset_name == 'ptb':
+ test = load_dataset("ptb_text_only", 'penn_treebank', split="validation")
+ encodings = tokenizer("\n\n".join(test["sentence"]), return_tensors="pt").input_ids
+ elif dataset_name == 'c4':
+ # WARNING: Many of the files in the allenai/c4 repo are marked as "Unsafe" by HuggingFace, possibly containing a virus. This particular file is not, and I doubt it's an issue, but worth noting.
+ test = load_dataset('allenai/c4', 'allenai--c4', data_files={'validation': 'en/c4-validation.00000-of-00008.json.gz'}, split='validation')
+ encodings = [tokenizer(x, return_tensors="pt").input_ids for x in test['text'][:1000]]
+ encodings = torch.cat(encodings, dim=1)
+ else:
+ raise ValueError(f"Unknown dataset {dataset_name}")
+
+ return encodings
+
+
+def calculate_perplexity(model, tokenizer, dataset: str, max_length: int, stride: int = 512) -> float:
+ print("Loading dataset...")
+ encodings = get_dataset(dataset, tokenizer)
+ seq_len = encodings.size(1)
+
+ print("Calculating perplexity...")
+ print(f"Sequence length: {seq_len}")
+ print(f"Max length: {max_length}")
+ print(f"Stride: {stride}")
+
+ nlls = []
+ prev_end_loc = 0
+
+ for begin_loc in (pbar := tqdm(range(0, seq_len - 1, stride))):
+ end_loc = min(seq_len - 1, begin_loc + max_length)
+ trg_len = end_loc - prev_end_loc # How many tokens we want to predict
+ input_ids = encodings[:, begin_loc:end_loc+1].to('cuda') # +1 for the labels
+
+ with torch.no_grad():
+ # Ask the model for logits
+ # NOTE: Instead of calling HF's model wrapper, we call the model directly to hopefully cut down on some memory overhead
+ outputs = model.model(input_ids[:, :-1], use_cache=False)
+ logits = model.lm_head(outputs[0][..., -trg_len:, :])
+
+ # The last trg_len tokens are the labels
+ labels = input_ids[:, -trg_len:].contiguous()
+
+ # Compute the NLL for this batch using flattened logits and labels
+ loss_fct = nn.CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, logits.size(-1)), labels.view(-1))
-Syriac Alphabet
-Syriac (ܐܬܘܪܝܐ)
+ nlls.append(loss.to('cpu').to(torch.float32))
+ ppl = torch.exp(torch.stack(nlls).mean())
+ pbar.set_description(f"Perplexity: {ppl:.2f}")
+
+ prev_end_loc = end_loc
+ if end_loc == (seq_len - 1):
+ break
+
+ ppl = torch.exp(torch.stack(nlls).mean())
+
+ return ppl
+
+
+if __name__ == '__main__':
+ main()
+
+
+[metadata]
+name = gptq_triton
+version = 0.0.3
+author = fpgaminer
+author_email = fpgaminer@bitcoin-mining.com
+description = Fast GPTQ kernels written in Triton
+long_description = file: README.md
+long_description_content_type = text/markdown; charset=UTF-8
+url = https://github.com/fpgaminer/GPTQ-triton
+keywords = gptq, triton, torch, cuda, gpu, quantization, quantize, quantized, inference, deep learning, machine learning
+license = Apache License 2.0
+license_file = LICENSE
+classifiers =
+ Development Status :: 3 - Alpha
+ License :: OSI Approved :: Apache Software License
+ Intended Audience :: Developers
+ Programming Language :: Python :: 3
+ Programming Language :: Python :: 3.6
+ Programming Language :: Python :: 3.7
+ Programming Language :: Python :: 3.8
+ Programming Language :: Python :: 3.9
+ Programming Language :: Python :: 3.10
+ Topic :: Scientific/Engineering :: Artificial Intelligence
+ Topic :: Software Development :: Libraries :: Python Modules
- short vowels are not usually written so many words are written with no vowel at all
- three styles of writing (estrangela, serto, mahdnaya) and two different ways of representing vowels
- basic alphabet in Estrangela style is: ܐ ܒ ܓ ܕ ܗ ܘ ܙ ܚ ܛ ܝ ܟ ܠ ܡ ܢ ܣ ܥ ܦ ܨ ܩ ܪ ܣ ܬ
- basic alphabet in Serto style is: ܬ, ܫ, ܪ, ܩ, ܨ, ܦ, ܥ, ܣ, ܢ, ܡ, ܠ, ܟ, ܝ, ܛ, ܚ, ܙ, ܘ, ܗ, ܕ, ܓ, ܒ, ܐ
- basic alphabet in Madnhaya style is: ܬ,ܫ,ܪ,ܩ,ܨ,ܦ,ܥ,ܣ,ܢ,ܡ,ܠ,ܟ,ܝ,ܛ,ܚ,ܙ,ܘ,ܗ, ܕ,ܓ,ܒ,ܐ
+[options]
+zip_safe = False
+include_package_data = False
+package_dir =
+ = src
+packages = find:
+python_requires = >=3.6
+install_requires =
+ triton >= 2.0.0
+ torch >= 2.0.0
+ transformers
+
+[options.packages.find]
+where = src
+
+import random
+
+from datasets import load_dataset
+
+
+def get_dataset(dataset_name: str, tokenizer, nsamples: int, seed: int, seqlen: int):
+ if dataset_name == "wikitext-2":
+ return get_wikitext2(nsamples, seed, seqlen, tokenizer)
+ elif dataset_name == 'ptb':
+ return get_ptb(nsamples, seed, seqlen, tokenizer, jointext='\n\n')
+ elif dataset_name == 'ptb-new':
+ return get_ptb(nsamples, seed, seqlen, tokenizer, jointext=' ')
+ elif dataset_name == 'c4':
+ return get_c4(nsamples, seed, seqlen, tokenizer)
+ else:
+ raise ValueError(f"Unknown dataset {dataset_name}")
+
+
+def get_wikitext2(nsamples: int, seed: int, seqlen: int, tokenizer, jointext: str = '\n\n'):
+ traindata = load_dataset('wikitext', 'wikitext-2-raw-v1', split='train')
+
+ trainenc = tokenizer(jointext.join(traindata['text']), return_tensors='pt')
+
+ rng = random.Random(seed)
+ trainloader = (rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1) for _ in range(nsamples))
+ trainloader = [trainenc.input_ids[:, i:i+seqlen] for i in trainloader]
+
+ return trainloader
+
+
+def get_ptb(nsamples: int, seed: int, seqlen: int, tokenizer, jointext: str):
+ traindata = load_dataset('ptb_text_only', 'penn_treebank', split='train')
+
+ trainenc = tokenizer(jointext.join(traindata['sentence']), return_tensors='pt')
+
+ rng = random.Random(seed)
+ trainloader = (rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1) for _ in range(nsamples))
+ trainloader = [trainenc.input_ids[:, i:i+seqlen] for i in trainloader]
+
+ return trainloader
+
+
+def get_c4(nsamples: int, seed: int, seqlen: int, tokenizer):
+ # WARNING: Many of the files in the allenai/c4 repo are marked as "Unsafe" by HuggingFace, possibly containing a virus. This particular file is not, and I doubt it's an issue, but worth noting.
+ traindata = load_dataset('allenai/c4', 'allenai--c4', data_files={'train': 'en/c4-train.00000-of-01024.json.gz'}, split='train')
+
+ rng = random.Random(seed)
+
+ trainloader = []
+ for _ in range(nsamples):
+ while True:
+ i = rng.randint(0, len(traindata) - 1)
+ trainenc = tokenizer(traindata[i]['text'], return_tensors='pt')
+ if trainenc.input_ids.shape[1] >= seqlen:
+ break
+
+ i = rng.randint(0, trainenc.input_ids.shape[1] - seqlen - 1)
+ inp = trainenc.input_ids[:, i:i + seqlen]
+ trainloader.append(inp)
+
+ return trainloader
+
+
+
+#!/usr/bin/env python3
+"""
+Benchmarks the generation speed of a model. While Benchmark.ipynb provides nice detailed performance data, it measures the kernels in isolation.
+This script measures "real world" performance by running the whole model in generation mode.
+It tests a grid of prompt lengths and generation lengths, and saves the timing results to `results.json`.
+"""
+import argparse
+import itertools
+import json
+import os
+import random
+import time
+
+import original_quant
+import torch
+import transformers
+from gptq_triton import load_quant
+from transformers import AutoTokenizer, LlamaConfig, LlamaForCausalLM
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--model', type=str, help='Path to model, either a HuggingFace model or a quantized model')
+parser.add_argument('--quant', action='store_true', help='Whether the model is quantized')
+parser.add_argument('--cuda', type=str, help='Whether to use the old CUDA kernel and format; this must be set to the path to the CUDA quantized model, and --model must be set to a HF model')
+parser.add_argument('--average', type=int, default=10, help='Number of times to run each test to get an average')
+
+
+def main():
+ args = parser.parse_args()
+
+ if args.cuda:
+ model = load_cuda_quant(args.model, args.cuda, 4, -1)
+ model.eval()
+ model.to('cuda')
+ elif not args.quant:
+ model = get_llama(args.model)
+ model.eval()
+ model.to('cuda')
+ else:
+ model = load_quant(args.model)
+ model.eval()
+ model.to('cuda')
+
+ tokenizer = AutoTokenizer.from_pretrained(args.model, use_fast=False)
+
+ prompt_lengths = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]
+ max_lengths = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]
+
+ lengths = set(itertools.product(prompt_lengths, max_lengths))
+
+ # Remove lengths that we've already tested
+ if os.path.exists('results.jsonl'):
+ with open('results.jsonl', 'r') as f:
+ for line in f:
+ line = json.loads(line)
+ key = (line['prompt_length'], line['max_length'])
+ if key in lengths:
+ lengths.remove(key)
+
+ # Shuffle the lengths so that we don't always test in the same order and get caching effects
+ lengths = list(lengths)
+ random.shuffle(lengths)
+
+ # TODO: For some reason the first run is always slow, so we run it once before the benchmark to warm things up
+ encoded_prompt = tokenizer.encode("TODO", add_special_tokens=False, return_tensors='pt').to('cuda')
+ _ = model.generate(
+ input_ids=encoded_prompt,
+ max_length=8,
+ do_sample=True,
+ num_return_sequences=1,
+ suppress_tokens=[model.generation_config.eos_token_id],
+ )
+
+ # Run the remaining benchmarks
+ with open('results.jsonl', 'a') as f:
+ for prompt_length, max_length in lengths:
+ print(f'Prompt length: {prompt_length}, max length: {max_length}')
+
+ results = []
+
+ for _ in range(args.average):
+ # Generate a long random string
+ # We do this every time to avoid caching effects
+ prompt = ''.join(random.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,;:!?') for _ in range(2048 * 10))
+
+ # Encode and crop down
+ encoded_prompt = tokenizer.encode(prompt, add_special_tokens=False, return_tensors='pt')
+ encoded_prompt = encoded_prompt[:, :prompt_length]
+ encoded_prompt = encoded_prompt.to('cuda')
+
+ start_time = time.time()
+ _ = model.generate(
+ input_ids=encoded_prompt,
+ max_length=max_length + prompt_length,
+ do_sample=True,
+ num_return_sequences=1,
+ suppress_tokens=[model.generation_config.eos_token_id], # This prevents the sampler from ending early; it must generate max_length tokens
+ )
+ end_time = time.time()
+
+ gen_time = end_time - start_time
+ speed = max_length / gen_time
+
+ results.append((gen_time, speed))
+
+ # Compute the average
+ avg_time = sum(t for t, _ in results) / len(results)
+ avg_speed = (max_length * len(results)) / sum(t for t, _ in results)
+
+ print(f'Average generation time: {avg_time:.2f} seconds')
+ print(f'Average generation speed: {avg_speed:.2f} tokens per second')
+ print()
+
+ f.write(json.dumps({
+ 'prompt_length': prompt_length,
+ 'max_length': max_length,
+ 'average_time': avg_time,
+ 'average_speed': avg_speed,
+ 'runs': results,
+ }))
+ f.write("\n")
+ f.flush()
+
+
+def get_llama(model: str):
+ """
+ Load a pretrained Llama model
+ """
+ def skip(*args, **kwargs):
+ pass
+ # NOTE: This is a nasty hack, but it speeds up model building by a huge amount
+ old_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
+ torch.nn.init.kaiming_uniform_ = skip
+ torch.nn.init.uniform_ = skip
+ torch.nn.init.normal_ = skip
+
+ model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
+ model.seqlen = 2048
+
+ # Restore the old initializers
+ torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = old_inits
+
+ return model
+
+
+def load_cuda_quant(model, checkpoint, wbits, groupsize):
+ """
+ Load a quantized model using the old CUDA kernel
+ """
+ config = LlamaConfig.from_pretrained(model)
+ def noop(*args, **kwargs):
+ pass
+ original_inits = (torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_)
+ torch.nn.init.kaiming_uniform_ = noop
+ torch.nn.init.uniform_ = noop
+ torch.nn.init.normal_ = noop
+
+ torch.set_default_dtype(torch.half)
+ original_init_weights = transformers.modeling_utils._init_weights
+ transformers.modeling_utils._init_weights = False
+ torch.set_default_dtype(torch.half)
+ model = LlamaForCausalLM(config)
+ torch.set_default_dtype(torch.float)
+
+ transformers.modeling_utils._init_weights = original_init_weights
+ torch.nn.init.kaiming_uniform_, torch.nn.init.uniform_, torch.nn.init.normal_ = original_inits
+
+ model = model.eval()
+ layers = original_quant.find_layers(model)
+ for name in ['lm_head']:
+ if name in layers:
+ del layers[name]
+ original_quant.make_quant(model, layers, wbits, groupsize, faster=False)
-Dravidian languages
+ del layers
- All Dravidian languages are written from left to right.
- All Dravidian languages have different scripts. But similarity can be found in their orthography.
+ print('Loading model ...')
+ if checkpoint.endswith('.safetensors'):
+ from safetensors.torch import load_file as safe_load
+ model.load_state_dict(safe_load(checkpoint))
+ else:
+ model.load_state_dict(torch.load(checkpoint))
+ model.seqlen = 2048
+ print('Done.')
-Kannada
+ return model
- Kannada has a 49 letter alphabet.
-Tamil
+if __name__ == '__main__':
+ main()
- common word endings :ள்ளது, கிறது, கின்றன, ம்
- common words: தமிழ், அவர், உள்ள, சில
- Tamil has a unique 30-letter alphabet. With the help of diacritics, as many as 247 letters can be written.
-அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ க ங ச ஞ ட ண த ந ப ம ய ர ல வ ழ ள ற ன
-Telugu
-Telugu has 56 characters (Aksharamulu) including vowels (Achchulu) and consonants (Hallulu). Telugu uses eighteen vowels, each of which has both an independent form and a diacritic form used with consonants to create syllables. The language makes a distinction between short and long vowels.
-అ ఆ ఇ ఈ ఉ ఊ ఋ ౠ ఌ ౡ ఎ ఏ ఐ ఒ ఓ ఔ అం అః క ఖ గ ఘ ఙ చ ఛ జ ఝ ఞ ట ఠ డ ఢ ణ త థ ద ధ న ప ఫ బ భ మ య ర ఱ ల ళ వ శ ష స హ
+VPS
-౦ ౧ ౨ ౩ ౪ ౫ ౬ ౭ ౮ ౯
-Bengali
+Oct 12, 2023
-The Bengali alphabet or Bangla alphabet (Bengali: বাংলা বর্ণমালা, bangla bôrnômala) or Bengali script (Bengali: বাংলা লিপি, bangla lipi) is the writing system, originating in the Indian subcontinent, for the Bengali language and is the fifth most widely used writing system in the world. The script is used for other languages like Assamese, Maithili, Meithei and Bishnupriya Manipuri, and has historically been used to write Sanskrit within Bengal.
-Bengali
+Ignas R.
-Bengali has unique 50 letter Alphabet.
+10min Read
+25 Common Linux Bash Script Examples to Get You Started
- The Bengali script has a total of 9 vowel graphemes, each of which is called a স্বরবর্ণ swôrôbôrnô "vowel letter". The swôrôbôrnôs represent six of the seven main vowel sounds of Bengali, along with two vowel diphthongs. All of them are used in both Bengali and Assamese languages.
+Bash or Bourne-again shell is one of the most popular shells and command languages for Linux VPS enthusiasts. It was first released in 1989 and was used as the default shell for most Linux distributions ever since.
-অ আ ই ঈ উ ঊ ঋ এ ঐ ও ঔ
+Bash scripting allows users and system administrators to automate processes and save hundreds of hours of manual work. It’s worth mentioning that Bash is also available for Windows and macOS.
- The Bengali script has a total of 39 Consonants. Consonant letters are called ব্যঞ্জনবর্ণ bænjônbôrnô "consonant letter" in Bengali. The names of the letters are typically just the consonant sound plus the inherent vowel অ ô. Since the inherent vowel is assumed and not written, most letters' names look identical to the letter itself (the name of the letter ঘ is itself ghô, not gh).
+This tutorial will introduce you to what bash scripting is. It features over twenty useful bash script examples to start your bash scripting journey.
-ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য র ল শ ষ স হ ড় ঢ় য় ৎ ঃ ং ঁ
+ What Is Bash Scripting Used For
+ 25 Bash Scripts Examples
+ 1. Hello World
+ 2. Echo Command
+ 3. Sleep Command
+ 4. Wait Command
+ 5. Comments
+ 6. Get User Input
+ 7. Loops
+ 8. Create an Array
+ 9. Conditional Statements
+ 10. Functions
+ 11. Display String Length
+ 12. Extract String
+ 13. Find and Replace String
+ 14. Concatenate Strings
+ 15. Check if a Number is Even or Odd
+ 16. Generate Factorial of Number
+ 17. Create Directories
+ 18. Read Files
+ 19. Print Files With Line Count
+ 20. Delete Files
+ 21. Test if File Exists
+ 22. Check Inodes and Disk Usage
+ 23. Send Email Example
+ 24. Update Packages
+ 25. Show Server Information
- has 10 diacritics denoting syllable rhymes -
+What Is Bash Scripting Used For
-া ি ী ু ূ ৃ ে ৈ ো ৌ
-Assamese
+Before we move on to the topic of bash scripting use cases, we need to elaborate on what bash and bash scripting are.
- The Assamese script has a total of 9 vowel graphemes, each of which is called a স্বরবর্ণ swôrôbôrnô "vowel letter" too.
+Bash is a command-line interface interpreter that runs in a text window where users can manage and execute shell commands. Bash – or shell scripting – on the other hand is the process of writing a set of commands to be executed on a Linux system. A file that includes such instructions is called a bash script.
-অ আ ই ঈ উ ঊ ঋ এ ঐ ও ঔ
+To put it simply, the bash interpreter reads the bash script and executes the commands at the same time. For example, a Linux user can execute hundreds of commands with a single click instead of inputting them one by one. For this reason, bash scripting is the go-to choice for increasing productivity, setting up automation, and eliminating repetitive tasks.
+25 Bash Scripts Examples
- has a total of 39 Consonants. Consonant letters are called ব্যঞ্জনবর্ণ bænjônbôrnô "consonant letter" in Bengali.
+The following section will cover 25 of the most popular bash scripting examples, including variable manipulation and echoing out various values. We will also cover functions, arrays, loops, and much more.
+1. Hello World
-ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য ৰ ল শ ষ স হ ড় ঢ় য় ৎ ঃ ং ঁ
+Hello World is the most simple bash script to start with. We will create a new variable called learningbash and print out the words Hello World. First, open a new shell script file with a text editor of your choice:
- has 10 diacritics denoting syllable rhymes -
+nano hello.sh
-া ি ী ু ূ ৃ ে ৈ ো ৌ
-Canadian Aboriginal syllabics
+Paste the following lines into it:
-In modern writing, Canadian Aboriginal syllabics are indicative of Cree languages, Inuktitut, or Ojibwe, though the latter two are also written in alternative scripts. The basic glyph set is ᐁ ᐱ ᑌ ᑫ ᒉ ᒣ ᓀ ᓭ ᔦ, each of which may appear in any of four orientations, boldfaced, superscripted, and with diacritics including ᑊ ᐟ ᐠ ᐨ ᒼ ᐣ ᐢ ᐧ ᐤ ᐦ ᕽ ᓫ ᕑ. This abugida has also been used for Blackfoot.
-Other North American syllabics
-Cherokee
+#!/bin/bash
+#Creates a new variable with a value of "Hello World"
+learningbash="Hello World"
+echo $learningbash
-Cherokee writing features a unique syllabary consisting of the following characters:
+The command-line window showcasing the output of the first bash script – Hello World
-ᎡᎢᎣᎤᎥᎦᎧᎨᎩᎪᎫᎬᎭᎮᎯᎰᎱᎲᎳᎴᎵᎶᎷᎸᎹᎺᎻᎼᎽᎾᎿᏀᏁᏂᏃᏄᏅᏆᏇᏈᏉᏊᏋᏌᏍᏎᏏᏐᏑᏒᏓᏔᏕᏖᏗᏘᏙᏚᏛᏜᏝᏞᏟᏠᏡᏢᏣᏤᏥᏦᏧᏨᏩᏪᏫᏬᏭᏮᏯᏰᏱᏲᏳᏴ.
-Artificial languages
-Esperanto (Esperanto)
+The first line (/bin/bash) is used in every bash script. It instructs the operating system to use a bash interpreter as a command interpreter.
+2. Echo Command
- words: de, la, al, kaj
- Six accented letters: ĉ Ĉ ĝ Ĝ ĥ Ĥ ĵ Ĵ ŝ Ŝ ŭ Ŭ, their corresponding H-system representation ch Ch gh Gh hh Hh jh Jh sh Sh u U or their corresponding X-system representation cx Cx gx Gx hx Hx jx Jx sx Sx ux Ux
- words ending in o, a, oj, aj, on, an, ojn, ajn, as, os, is, us, u, i, aŭ
+The echo bash command can be used to print out text as well as values of variables. In the following example, we will showcase how quotation marks affect the echo command. We will start by opening a new bash script file:
-Klingon (tlhIngan Hol)
+nano echo.sh
- When written in the Latin alphabet Klingon has the unusual property of a distinction in case; q and Q are different letters, and other letters are either always (e.g. D, I, S) or never (e.g. ch, tlh, v) written in upper case. This causes a large number of words that look quite strange to people who aren't used to it, for example: yIDoghQo', tlhIngan Hol (with mixed case).
- The apostrophe is fairly frequent, especially at the end of a word or syllable.
- Common suffixes: -be', -'a'
- Common words: 'oH, Qapla'
- May use one or more apostrophes in the middle of a word: SuvwI″a'
+This simple bash script example will create a new variable and print it out while using different quotation marks.
-Lojban (lojban.)
+#!/bin/bash
+provider="Hostinger"
+echo 'The best hosting provider is $provider'
+echo "The best hosting provider is $provider"
- (almost) all lowercase;
- common words lo, mi, cu, la, nu, do, na, se;
- paragraphs delimited with ni'o and sentences delimited with .i (or i);
- many five-letter words in consonant-vowel shape CCVCV or CVCCV;
- many short words with apostrophes between vowels, like ko'a pi'o etc.;
- usually no punctuation except for dots;
- may use commas in the middle of words (typically proper nouns).
+The command-line window shows the echo command
-Toki Pona (toki pona)
+As you can see, if the echo bash command is used with double quotation marks ““, then the script will print out the actual value of a variable. Otherwise, if the single quotation marks ‘‘ are used, it will print out only the name of a variable.
+3. Sleep Command
- alphabet is all lowercase except loanwords
- no diacritics
- only uses unvoiced consonants in writing, e.g. p, t, k
+Sleep command halts all currently running bash scripts and puts the system to sleep. Start by creating a new bash script file:
-Full alphabet: p, t, k, s, m, n, l, j, w, a, e, i, o, u
+nano sleep.sh
- common words li, mi, e, sina, ona, jan
- often sounds like a simplified and phonetic form of English or Swedish
- many two-syllable words
+Then, paste in the following simple script:
+#!/bin/bash
+sleep 10 && echo “I’ve been sleeping for 10 seconds, I want more” && sleep 10 && echo “I’m done sleeping, thanks!”
-!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~DÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø׃áíóúñѪº¿®¬½¼¡«»░▒▓│┤ÁÂÀ©╣║╗╝¢¥┐└┴┬├─┼ãÃ╚╔╩╦╠═╬¤ðÐÊËÈıÍÎÏ┘┌█▄¦Ì▀ÓßÔÒõÕµþÞÚÛÙýݯ´¬±‗¾¶§÷¸°¨•¹³²■
+A bash script with the sleep command. The basic idea is that it puts the system to a halt for a set amount of time
-㧟㩳㭎㳠䁖䄍䌷䓖䘯䜣䜩䝼䞍䥇䥺䦂䦃䦆䦛䦟䦶䲟䲠䲡䲣䴓䴔䴕䴖䴗䴘䴙䶮一丁七万丈三上下不与丐丑专且丕世丘丙业丛东丝丞丢两严丧丨个丫中丰串临丶丸丹为主丽举丿乃久乇么义之乌乍乎乏乐乒乓乔乖乘乙乜九乞也习乡书乩买乱乳乾亅了予争事二于亏云互亓五井亘亚些亟亠亡亢交亥亦产亨亩享京亭亮亲亳亵人亿什仁仂仃仄仅仆仇仉今介仍从仑仓仔仕他仗付仙仝仞仟仡代令以仨仪仫们仰仲仳仵件价任份仿企伉伊伍伎伏伐休众优伙会伛伞伟传伢伤伥伦伧伪伫伯估伲伴伶伸伺似伽佃但位低住佐佑体何佗佘余佚佛作佝佞佟你佣佤佥佧佩佬佯佰佳佴佶佻佼佾使侃侄侈侉例侍侏侑侔侗供依侠侣侥侦侧侨侩侪侬侮侯侵便促俄俅俊俎俏俐俑俗俘俚俜保俞俟信俣俦俨俩俪俭修俯俱俳俸俺俾倌倍倏倒倔倘候倚倜借倡倥倦倨倩倪倬倭倮倳债值倾偃假偈偌偎偏偕做停健偬偶偷偻偾偿傀傅傈傍傣傥傧储傩催傲傺傻像僖僚僦僧僬僭僮僳僵僻儆儇儋儒儡儿兀允元兄充兆先光克免兑兔兕兖党兜兢入全八公六兮兰共关兴兵其具典兹养兼兽冀冁冂内冈冉册再冒冕冖冗写军农冠冢冤冥冫冬冯冰冱冲决况冶冷冻冼冽净凄准凇凉凋凌减凑凛凝几凡凤凫凭凯凰凳凵凶凸凹出击凼函凿刀刁刃分切刈刊刍刎刑划刖列刘则刚创初删判刨利别刭刮到刳制刷券刹刺刻刽刿剀剁剂剃削剌前剐剑剔剖剜剞剡剥剧剩剪副割剽剿劁劂劈劐劓力劝办功加务劢劣动助努劫劬劭励劲劳劾势勃勇勉勋勐勒勖勘募勤勰勹勺勾勿匀包匆匈匍匏匐匕化北匙匚匝匠匡匣匦匪匮匸匹区医匾匿十千卅升午卉半华协卑卒卓单卖南博卜卞卟占卡卢卣卤卦卧卩卫卮卯印危即却卵卷卸卺卿厂厄厅历厉压厌厍厕厘厚厝原厢厣厥厦厨厩厮厶去县叁参又叉及友双反发叔取受变叙叛叟叠口古句另叨叩只叫召叭叮可台叱史右叵叶号司叹叻叼叽吁吃各吆合吉吊同名后吏吐向吒吓吕吖吗君吝吞吟吠吡吣否吧吨吩含听吭吮启吱吲吴吵吸吹吻吼吾呀呃呆呈告呋呐呒呓呔呕呖呗员呙呛呜呢呤呦周呱呲味呵呶呷呸呻呼命咀咂咄咆咋和咎咏咐咒咔咕咖咙咚咛咝咣咤咦咧咨咩咪咫咬咭咯咱咳咴咸咻咽咿哀品哂哄哆哇哈哉哌响哎哏哐哑哒哓哔哕哗哙哚哜哝哞哟哥哦哧哨哩哪哭哮哲哳哺哼哽哿唁唆唇唉唏唐唑唔唛唠唢唣唤唧唪唬售唯唰唱唳唷唼唾唿啁啃啄商啉啊啐啕啖啜啡啤啥啦啧啪啬啭啮啵啶啷啸啻啼啾喀喁喂喃善喇喈喉喊喋喏喑喔喘喙喜喝喟喧喱喳喵喷喹喻喽喾嗄嗅嗉嗌嗍嗑嗒嗓嗔嗖嗜嗝嗟嗡嗣嗤嗥嗦嗨嗪嗫嗬嗯嗲嗳嗵嗷嗽嗾嘀嘁嘈嘉嘌嘎嘏嘘嘛嘞嘟嘣嘤嘧嘬嘭嘱嘲嘴嘶嘹嘻嘿噌噍噎噔噗噘噙噜噢噤器噩噪噫噬噱噶噻噼嚅嚆嚎嚏嚓嚣嚯嚷嚼囊囔囗囚四囝回囟因囡团囤囫园困囱围囵囹固国图囿圃圄圆圈圉圊圜土圣在圩圪圬圭圮圯地圳圹场圻圾址坂均坊坌坍坎坏坐坑块坚坛坜坝坞坟坠坡坤坦坨坩坪坫坭坯坳坶坷坻坼垂垃垄垅垆型垌垒垓垛垠垡垢垣垤垦垧垩垫垭垮垲垴垸埂埃埋城埏埒埔埕埘埙埚埝域埠埤埭埯埴埸培基埽堀堂堆堇堊堋堍堑堕堙堞堠堡堤堪堰堵塄塌塍塑塔塘塞塥塩填塬塾墀墁境墅墉墒墓墙墚增墟墨墩墼壁壅壑壕壤士壬壮声壳壶壹夂处备夊复夏夔夕外夙多夜够夤夥大天太夫夭央夯失头夷夸夹夺夼奁奂奄奇奈奉奋奎奏契奔奕奖套奘奚奠奢奥女奴奶奸她好妁如妃妄妆妇妈妊妍妒妓妖妗妙妞妣妤妥妨妩妪妫妮妯妲妹妻妾姆姊始姐姑姒姓委姗姘姚姜姝姣姥姨姬姹姻姿威娃娄娅娆娇娈娉娌娑娓娘娜娟娠娣娥娩娱娲娴娶娼婀婆婉婊婕婚婢婧婪婴婵婶婷婺婿媒媚媛媪媲媳媵媸媾嫁嫂嫉嫌嫒嫔嫖嫘嫜嫠嫡嫣嫦嫩嫫嫱嬉嬖嬗嬲嬴嬷孀子孑孓孔孕字存孙孚孛孜孝孟孢季孤孥学孩孪孬孰孱孳孵孺孽宀宁它宄宅宇守安宋完宏宓宕宗官宙定宛宜宝实宠审客宣室宥宦宪宫宰害宴宵家宸容宽宾宿寂寄寅密寇富寐寒寓寝寞察寡寤寥寨寮寰寸对寺寻导寿封射将尉尊小少尔尕尖尘尚尜尝尢尤尥尧尬就尴尸尹尺尻尼尽尾尿局屁层居屈屉届屋屎屏屐屑展屙属屠屡屣履屦屮屯山屹屺屿岁岂岈岌岍岐岑岔岖岗岘岙岚岛岜岢岣岩岫岬岭岱岳岵岷岸岽岿峁峄峋峒峙峡峤峥峦峨峪峭峰峻崂崃崆崇崎崔崖崛崞崤崦崧崩崭崮崴崽崾嵇嵊嵋嵌嵘嵛嵝嵩嵫嵬嵯嵴嶂嶙嶝嶷嶼巅巍巛川州巡巢工左巧巨巩巫差巯己已巳巴巷巽巾币市布帅帆师希帏帐帑帔帕帖帘帙帚帛帜帝带帧席帮帱帷常帻帼帽幂幄幅幌幔幕幛幞幡幢干平年并幸幺幻幼幽广庀庄庆庇床庋序庐庑库应底庖店庙庚府庞废庠庥度座庭庳庵庶康庸庹庾廉廊廑廒廓廖廛廨廪廴延廷建廾廿开弁异弃弄弈弊弋式弑弓引弗弘弛弟张弥弦弧弩弭弯弱弹强弼彀彐归当录彖彗彘彝彡形彤彦彩彪彬彭彰影彳彷役彻彼往征徂径待徇很徉徊律後徐徒徕得徘徙徜御徨循徭微徵德徼徽心必忆忉忌忍忏忐忑忒忖志忘忙忝忠忡忤忧忪快忭忮忱念忸忻忽忾忿怀态怂怃怄怅怆怊怍怎怏怒怔怕怖怙怛怜思怠怡急怦性怨怩怪怫怯怵总怼怿恁恂恃恋恍恐恒恕恙恚恝恢恣恤恧恨恩恪恫恬恭息恰恳恶恸恹恺恻恼恽恿悃悄悉悌悍悒悔悖悚悛悝悟悠患悦您悫悬悭悯悱悲悴悸悻悼情惆惊惋惑惕惘惚惜惝惟惠惦惧惨惩惫惬惭惮惯惰想惴惶惹惺愀愁愆愈愉愍愎意愕愚感愠愣愤愦愧愫愿慈慊慌慎慑慕慝慢慧慨慰慵慷憋憎憔憝憧憨憩憬憷憾懂懈懊懋懑懒懔懦懵懿戆戈戊戋戌戍戎戏成我戒戕或戗战戚戛戟戡戢戤戥截戬戮戳戴戶户戽戾房所扁扃扇扈扉手才扎扑扒打扔托扛扣扦执扩扪扫扬扭扮扯扰扳扶批扼找承技抄抉把抑抒抓投抖抗折抚抛抟抠抡抢护报抨披抬抱抵抹抻押抽抿拂拄担拆拇拈拉拊拌拍拎拐拒拓拔拖拗拘拙拚招拜拟拢拣拥拦拧拨择括拭拮拯拱拳拴拶拷拼拽拾拿持挂指挈按挎挑挖挚挛挝挞挟挠挡挢挣挤挥挨挪挫振挲挹挺挽捂捃捅捆捉捋捌捍捎捏捐捕捞损捡换捣捧捩捭据捱捶捷捺捻掀掂掇授掉掊掌掎掏掐排掖掘掠探掣接控推掩措掬掭掮掰掳掴掷掸掺掼掾揄揆揉揍揎描提插揖揞揠握揣揩揪揭揲援揶揸揽揿搀搁搂搅搋搌搏搐搓搔搛搜搞搠搡搦搪搬搭搴携搽搿摁摄摅摆摇摈摊摒摔摘摞摧摩摭摸摹摺撂撄撅撇撑撒撕撙撞撤撩撬播撮撰撵撷撸撺撼擀擂擅操擎擐擒擓擗擘擞擢擤擦攀攉攒攘攥攫攮支攴攵收攸改攻放政故效敉敌敏救敕敖教敛敝敞敢散敦敫敬数敲整敷文斋斌斐斑斓斗料斛斜斟斡斤斥斧斩斫断斯新方於施旁旃旄旅旆旋旌旎族旒旖旗无既日旦旧旨早旬旭旮旯旰旱时旷旺昀昂昃昆昊昌明昏易昔昕昙昝星映春昧昨昭是昱昴昵昶昼显晁晃晋晌晏晒晓晔晕晖晗晚晟晡晤晦晨普景晰晴晶晷智晾暂暄暇暌暑暖暗暝暧暨暮暴暹暾曙曛曜曝曦曩曰曲曳更曷曹曼曾替最月有朊朋服朐朔朕朗望朝期朦木未末本札术朱朴朵机朽杀杂权杆杈杉杌李杏材村杓杖杜杞束杠条来杨杩杪杭杯杰杲杳杵杷杼松板极构枇枉枋析枕林枘枚果枝枞枢枣枥枧枨枪枫枭枯枰枳枵架枷枸柁柃柄柏某柑柒染柔柘柙柚柜柝柞柠柢查柩柬柯柰柱柳柴柽柿栀栅标栈栉栊栋栌栎栏树栓栖栗栝校栩株栲栳样核根格栽栾桀桁桂桃桄桅框案桉桌桎桐桑桓桔桕桠桡桢档桤桥桦桧桨桩桫桴桶桷梁梃梅梆梏梓梗梢梦梧梨梭梯械梳梵检棂棉棋棍棒棕棘棚棠棡棣森棰棱棵棹棺棼椁椅椋植椎椐椒椟椠椤椭椰椴椹椽椿楂楔楗楚楝楞楠楣楦楫楮楱楷楸楹楼榀概榄榆榇榈榉榍榔榕榘榛榜榧榨榫榭榱榴榷榻槁槊槌槎槐槔槛槟槠槭槲槽槿樊樗樘樟模樨横樯樱樵樽樾橄橇橐橘橙橛橡橥橱橹橼檀檄檎檐檑檗檠檩檫檬欠次欢欣欤欧欲欷欹欺款歃歆歇歉歌歙止正此步武歧歪歹死歼殁殂殃殄殆殇殉殊残殍殒殓殖殚殛殡殪殳殴段殷殿毁毂毅毋母每毒毓比毕毖毗毙毛毡毫毯毳毵毹毽氅氆氇氍氏氐民氓气氕氖氘氙氚氛氟氡氢氤氦氧氨氩氪氮氯氰氲水永氽汀汁求汆汇汉汊汐汔汕汗汛汜汝汞江池污汤汨汩汪汰汲汴汶汹汽汾沁沂沃沅沆沈沉沌沏沐沓沔沙沛沟没沣沤沥沦沧沩沪沫沭沮沱沲河沸油治沼沽沾沿泄泅泉泊泌泐泓泔法泖泗泛泞泠泡波泣泥注泪泫泮泯泰泱泳泵泶泷泸泺泻泼泽泾洁洄洇洋洌洎洒洗洙洚洛洞津洧洪洫洮洱洲洳洵洹活洼洽派流浃浅浆浇浊测浍济浏浑浒浓浔浙浚浜浞浠浣浦浩浪浮浯浴海浸浼涂涅消涉涌涎涑涓涔涕涛涝涞涟涠涡涣涤润涧涨涩涪涫涮涯液涵涸涿淀淄淅淆淇淋淌淑淖淘淙淝淞淠淡淤淦淫淬淮深淳混淹添淼清渊渌渍渎渐渑渔渖渗渚渝渠渡渣渤渥温渫渭港渲渴游渺湃湄湍湎湓湔湖湘湛湟湫湮湾湿溃溅溆溉溏源溘溜溟溢溥溧溪溯溱溲溴溶溷溺溻溽滁滂滇滋滏滑滓滔滕滗滚滞滟滠满滢滤滥滦滨滩滴滹漂漆漉漏漓演漕漠漤漩漪漫漭漯漱漳漶漾潆潇潋潍潘潜潞潢潦潭潮潲潴潸潺潼澄澈澉澌澍澎澜澡澧澳澶澹澾激濂濉濑濒��濠濡濮濯瀑瀚瀛瀣瀹灌灏灞火灭灯灰灵灶灸灼灾灿炀炅炉炊炎炒炔炕炖炙炜炝炫炬炭炮炯炱炳炷炸点炻炼炽烀烁烂烃烈烊烘烙烛烟烤烦烧烨烩烫烬热烯烷烹烽焉焊焐焓焕焖焘焙焚焦焯焰焱然煅煊煌煎煙煜煞煤煦照煨煮煲煳煸煺煽熄熊熏熔熘熙熟熠熨熬熳熵熹燃燎燔燕燠燥燧燮燹爆爝爨爪爬爰爱爵父爷爸爹爻爽爿片版牌牍牒牖牙牛牝牟牡牢牦牧物牯牲牵特牺牾牿犀犁犄犊犋犍犏犒犟犬犯犰犴状犷犸犹狁狂狃狄狈狍狎狐狒狗狙狞狠狡狨狩独狭狮狯狰狱狲狳狴狷狸狺狻狼猁猃猊猎猓猕猖猗猛猜猝猞猡猢猥猩猪猫猬献猱猴猷猸猹猾猿獍獐獒獗獠獬獭獯獾玄率玉王玎玑玖玛玟玢玩玫玮环现玲玳玷玺玻珀珂珈珉珊珍珏珐珑珙珞珠珥珧珩班珲球琅理琉琊琏琐琚琛琢琥琦琨琪琬琮琰琳琴琵琶琼瑁瑕瑗瑙瑚瑛瑜瑞瑟瑭瑰瑶瑷瑾璀璁璃璇璋璎璐璜璞璧璨璩璺瓒瓜瓞瓠瓢瓣瓤瓦瓮瓯瓴瓶瓷瓿甄甍甏甑甓甘甙甚甜生甥用甩甫甬甭甯田由甲申电男甸町画甾畀畅畈畋界畎畏畔留畚畛畜畝略畦番畲畴畸畹畿疃疆疋疏疑疒疔疖疗疙疚疝疟疠疡疣疤疥疫疬疮疯疰疱疲疳疴疵疸疹疼疽疾痂痃痄病症痈痉痊痍痒痔痕痖痘痛痞痢痣痤痦痧痨痪痫痰痱痴痹痼痿瘀瘁瘅瘊瘌瘐瘕瘗瘘瘙瘛瘟瘠瘢瘤瘥瘦瘩瘪瘫瘰瘳瘴瘵瘸瘼瘾瘿癀癃癌癍癔癖癜癞癣癫癯癶癸登白百皂的皆皇皈皋皎皑皓皖皙皤皮皱皲皴皿盂盅盆盇盈盉益盌盍盎盏盐监盒盓盔盕盖盗盘盛盜盝盞盟盠盡盢監盤盥盦盨盩盪盫盬目盯盱盲盳直相盹盻盼盽盾盿眀省眃眄眅眆眇眈眉眊看県眍眎眏眕眖眘眙眚眜眞真眠眢眣眥眦眨眩眫眬眭眮眯眰眲眳眵眶眷眸眹眺眼眾着睁睃睄睅睆睇睉睊睋睍睎睏睐睑睒睕睖睘睙睚睛睞睠睡睢督睥睦睧睨睩睪睫睬睱睴睹睺睻睽睾睿瞀瞂瞄瞅瞆瞇瞋瞌瞍瞎瞏瞐瞑瞒瞓瞕瞜瞞瞟瞠瞡瞢瞣瞥瞧瞩瞪瞫瞬瞭瞰瞳瞵瞷瞻瞼瞽瞿矀矂矃矄矅矇矊矍矎矒矔矗矘矙矚矛矜矝矞矟矡矢矣知矧矩矫矬短矮矯矰石矵矶矸矺矻矽矾矿砀码砂砉砌砍砏砑砒研砖砗砘砚砛砜砝砟砢砣砤砥砦砧砩砪砫砬砭砮砰砲破砷砸砹砺砻砼砾础硁硂硃硄硅硇硈硊硌硎硏硐硒硕硖硗硙硚硝硟硣硪硫硬硭确硱硷硼硽碀碁碃碅碇碉碌碍碎碑碒碓碔碕碗碘碚碛碜碟碠碡碣碥碦碧碩碭碰碱碲碳碴碵碶碸確碻碼碽碾磁磃磄磅磈磉磊磋磐磑磔磕磙磚磜磞磠磡磣磥磦磨磩磪磫磬磭磯磲磳磴磷磸磹磺磻磽磾磿礀礁礂礄礅礇礈礉礊礋礌礎礐礑礒礓礘礙礜礞礡礤礦礨礮礱礴示礼礽社礿祀祁祂祃祅祆祇祈祉祋祎祏祐祓祔祕祖祗祘祙祚祛祜祝神祟祠祢祤祥祦祧票祩祪祫祭祮祯祰祲祳祶祷祸祹祺祻祼祾祿禀禁禃禄禅禆禇禊禋禌禍禎福禐禑禔禖禗禘禛禜禞禠禡禢禣禤禥禦禧禨禩禪禫禬禭禮禰禱禳禵禸禹禺离禽禾禿秀私秃秅秆秉秋秌种科秒秔秕秘秙租秠秢秣秤秦秧秩秫秬秭积称秱秲秳秵秶秸秹秺移秼秽秾稀稂稃稄稅稆稇稈程稌稍税稑稓稔稖稗稘稙稚稛稜稞稟稠稡稣稧稬稭種稱稲稳稴稷稸稹稻稼稽稿穀穃穄穆穈穉穊積穐穑穗穙穛穜穟穢穩穪穫穯穰穱穴穵究穷穸穹空穻穽穿窀突窃窄窅窆窇窈窊窋窌窍窎窑窒窔窕窖窗窘窜窝窟窠窣窤窥窦窨窩窪窫窬窭窮窯窳窸窼窾窿竂竄竅竇竈立竌竏竑竒竖站竚竝竞竟章竢竣竤童竦竭端競竷竸竹竺竽竾竿笀笃笄笆笇笈笉笊笋笍笎笏笐笑笔笕笖笗笙笛笜笞笟笠笣笤笥符笧笨笪笫第笭笮笰笱笲笳笸笹笺笼笾笿筂筅筆筇筈等筊筋筌筍筏筐筑筒答策筘筚筛筝筠筢筣筥筦筩筭筮筰筱筲筴筵筶筷筸筹筻筼筽签简箅箇箋箍箏箐箒箓箔箕箖算箘箛箜箝箞箠管箢箣箤箥箦箧箨箩箪箫箬箭箯箱箴箷箸箹箽箾箿節篁篂篃範篆篇築篌篑篓篙篚篛篜篝篟篠篡篤篥篦篨篩篪篬篭篮篯篰篱篲篳篴篷篸篺篼篾簃簇簋簌簍簏簑簕簘簜簞簟簠簡簢簤簥簦簧簨簪簫簬簯簰簳簴簷簸簹簺簻簼簽簾簿籀籁籂籄籆籇籋籌籍籐籒籓籔籙籜籞籠籣籤籥籬籲米籴籶类籼籽粃粉粊粋粌粍粎粏粐粑粒粓粔粕粖粗粘粚粛粜粝粞粟粡粢粣粤粥粦粧粩粪粫粭粮粯粱粲粳粴粵粶粷粸粹粺粻粼粽精粿糀糁糂糅糇糈糉糊糌糍糓糕糖糗糙糜糞糟糠糢糦糧糨糮糯糰糱糴糵糷糸糺系紀紂紃約紅紇紊紋納紏紐紓純紖紗紘紙級紛紝素索紣紤紧紩紫紬紭紮累細紳紵紹紺紻紾絁終絃組絅絆絍絏結絒絓絕絙絛絜絞絟絡絣給絨絪絫絭絮統絲絳絶絷絹絺絼絽絾絿綀綂綄綅綈綊綍綎綏綑綒經綔綖綗綜綝綟綠綡綦維綮綱網綴綵綶綹綼綿緄緅緊緋緌緍緐緒緗線緛緜緝緞締緡緣緤緦編緩緯緰緱緲練緵緶緷緹緺緻緼縀縁縂縆縈縋縕縚縛縜縞縠縡縢縣縧縩縪縫縮縯縱縷縹縻縼總績縿繀繁繂繃繆繇繉繋繌繐繑繒織繕繖繙繚繜繝繞繟繣繤繧���繩繫繬繯繳繴繸繺繻繼繿纀纁纂纃纄纉續纍纏纑纒纔纕纖纗纘纛纠纡红纣纤纥约级纨纩纪纫纬纭纮纯纰纱纲纳纴纵纶纷纸纹纺纻纽纾线绀绁绂练组绅细织终绉绊绋绌绍绎经绐绑绒结绔绕绖绗绘给绚绛络绝绞统绠绡绢绣绤绥绦继绨绩绪绫续绮绯绰绱绲绳维绵绶绷绸绹绺绻综绽绾绿缀缁缂缃缄缅缆缇缈缉缊缋缌缍缎缏缑缒缓缔缕编缗缘缙缚缛缜缝缞缟缠缡缢缣缤缥缦缧缨缩缪缫缬缭缮缯缰缱缲缳缴缵缶缷缸缺缻缽缾罁罂罃罄罅罆罇罈罋罍罐网罔罕罗罘罙罚罝罟罡罢罣罥罨罩罪置罯罰罱署罴罵罶罷罹罼罽罾羀羁羅羇羈羉羊羌美羑羔羕羗羙羚羜羝羞羟羠羡羣群羧義羭羮羯羰羲羴羵羶羷羸羹羺羼羽羿翀翁翂翃翅翆翈翉翊翌翎翐翑習翔翕翖翘翙翚翛翜翟翠翡翢翣翥翦翧翩翫翬翭翮翯翰翱翳翸翹翻翼耀老考耄者耆耇耈耊耋而耍耎耐耑耒耕耖耗耘耙耜耡耢耥耦耧耨耩耪耮耰耱耳耴耵耶耷耸耻耽耿聂聃聆聊聋职聍聒联聖聘聚聛聜聝聞聟聠聡聣聦聧聩聪聫聬聭聯聰聱聲聴聵聶職聸聹聺聻聽聾聿肀肃肄肅肆肇肉肊肋肌肍肏肓肖肘肙肚肛肜肝肞肟肠股肢肣肤肥肧肩肪肫肭肮肯肰肱育肴肷肸肺肻肼肽肾肿胀胁胂胃胄胆胊背胍胎胑胔胖胗胙胚胛胜胝胞胠胡胤胥胧胨胩胪胫胬胭胯胰胱胲胳胴胵胶胸胹胺胼能胾脂脅脆脈脉脊脍脎脏脐脑脒脓脔脕脖脗脘脙脚脛脜脝脞脟脣脦脧脨脩脫脬脭脮脯脰脱脲脳脵脶脷脸脹脺脻脼脽脾脿腀腂腃腄腆腈腊腋腌腎腐腑腓腔腕腗腘腙腚腠腣腥腦腧腨腩腪腫腬腭腮腰腱腳腴腵腸腹腺腻腼腽腾腿膀膂膄膆膈膊膋膏膑膕膗膘膚膛膜膝膟膠膥膦膨膩膪膫膬膭膮膯膰膱膲膳膴膵膶膹膺膻膼膽膿臀臁臂臃臄臅臆臇臈臉臊臋臌臍臎臏臐臑臒臓臕臖臗臘臚臛臜臞臟臢臣臥臧臨自臬臭臮臯至致臶臺臻臼臾臿舀舁舂舃舄舅舆與興舉舊舋舌舍舐舒舔舖舛舜舞舟舡舢舣舦舨航舫般舭舯舰舱舲舳舴舵舶舷舸船舻舾艁艂艄艆艇艈艉艊艋艍艎艏艐艑艒艕艖艘艙艚艜艞艟艢艣艤艦艧艨艩艫艭艮良艰色艳艴艶艷艸艺艼艽艾艿节芃芄芈芊芋芍芎芏芑芒芖芗芘芙芜芝芟芡芤芥芦芨芩芪芫芬芭芮芯芰花芳芴芵芷芸芹芻芼芽芾苁苃苄苅苇苈苊苋苌苍苎苏苑苒苓苔苕苗苘苙苛苜苞苟苠苡苣苤若苦苧苫苯英苲苴苶苷苹苻苼苽苾苿茀茁茂范茄茅茆茇茈茉茊茌茍茎茏茐茑茔茕茖茗茚茛茜茝茞茢茣茧茨茫茬茭茯茱茲茴茵茶茷茸茹茺茻茼茽茿荀荃荄荅荆荇荈草荊荏荐荑荒荔荖荘荙荚荛荜荞荟荠荡荢荣荤荥荦荧荨荩荪荫荬荭荮药荳荷荸荻荼荽莁莂莅莆莉莊莎莒莓莕莖莘莙莚莛莜莞莠莢莤莨莩莪莫莱莲莳莴莵莶获莸莹莺莻莼莽莾莿菀菁菂菃菄菅菆菇菉菊菌菍菏菐菑菒菓菔菕菖菘菙菚菜菝菞菟菠菡菢菣菥菦菧菨菩菪菫菬菭華菰菱菲菳菴菵菸菹菽萁萃萄萆萈萊萋萌萍萎萏萑萗萘萚萜萝萢萤营萦萧萨萩萬萱萵萸萼落葆葇葉葋葌葍葎葏葑葔葖著葘葙葚葛葜葞葟葠葡葢董葦葨葩葫葬葭葮葯葰葱葲葳葴葵葶葷葸葹葺葻葾蒁蒂蒃蒄蒇蒈蒉蒋蒌蒐蒑蒕蒗蒘蒙蒜蒞蒟蒡蒧蒨蒪蒭蒯蒲蒴蒷蒸蒹蒺蒻蒼蒽蒾蒿蓁蓂蓃蓄蓆蓇蓉蓊蓋蓍蓏蓐蓑蓓蓔蓕蓖蓗蓙蓚蓛蓝蓞蓟蓠蓡蓣蓥蓦蓧蓨蓬蓮蓯蓰蓱蓳蓴蓵蓷蓸蓺蓼蓾蓿蔀蔁蔂蔄蔊蔌蔎蔑蔓蔔蔗蔘蔙蔚蔞蔟蔡蔣蔥蔦蔫蔬蔯蔱蔲蔴蔷蔸蔺蔻蔼蔽蔿蕁蕂蕃蕅蕈蕉蕊蕋蕌蕒蕖蕗蕘蕙蕚蕛蕜蕝蕞蕟蕡蕣蕤蕦蕧蕨蕰蕲蕳蕴蕵蕷蕹蕺蕻蕼蕾蕿薀薂薃薄薅薆薇薋薏薐薑薔薖薗薙薛薜薝薠薢薤薦薨薪薭薮薯薰薳薷薹薾薿藀藁藇藉藍藏藐藑藓藕藖藗藘藙藚藛藜藝藞藠藢藣藤藥藦藧藨藩藫藬藭藮藯藰藳藴藵藶藷藺藻藿蘁蘂蘅蘆蘇蘋蘌蘑蘓蘔蘖蘘蘧蘩蘪蘭蘸蘼蘿虀虃虈虋虍虎虏虐虑虒虔處虖虗虘虙虚虛虜虝虞號虡虢虧虫虬虮虯虰虱虲虵虹虺虻虼虽虾虿蚀蚁蚂蚈蚊蚋蚌蚍蚑蚒蚓蚕蚖蚘蚜蚝蚡蚢蚣蚤蚧蚨蚩蚪蚬蚯蚰蚱蚴蚵蚶蚺蚾蚿蛀蛄蛆蛇蛉蛊蛋蛎蛏蛐蛑蛔蛖蛘蛙蛚蛛蛜蛞蛟蛡蛢蛣蛤蛥蛩蛬蛭蛮蛯蛰蛱蛲蛳蛴蛶蛷蛸蛹蛻蛾蜀蜁蜂蜃蜆蜇蜈蜉蜊蜌蜍蜎蜏蜐蜑蜒蜓蜔蜕蜗蜘蜚蜜蜞蜠蜡蜢蜣蜥蜨蜩蜪蜫蜮蜱蜴蜷蜸蜺蜻蜼蜽蜾蜿蝀蝄蝇蝈蝉蝌蝍蝎蝑蝓蝕蝗蝘蝙蝝蝟蝠蝣蝤蝥蝦蝨蝮蝰蝴蝶蝸蝹蝺蝻蝼蝽蝾蝿螀螁螂螃螅螈螋融螐螑螓螕螖螗螘螚螝螞螟螠螡螢螣螤螥螦螧螨螫螬螭螯螳螵螺螽蟀蟂蟅蟆蟊蟋蟑蟒蟓蟛蟜蟝蟠蟢蟥蟧蟨蟪蟫蟬蟭蟮蟯蟲蟳蟹蟻蟼蟾蟿蠃蠄蠅蠆蠈蠊蠋蠌蠍蠎蠏蠒蠓蠔蠕蠖蠗蠙蠚蠛蠜蠝蠟蠡蠢蠣蠥蠩蠪蠭蠲蠶蠷蠹蠻蠼蠾血衂衄衅衋行衍衒術衔衕衖街衘衙衛衝衟衡衢衣补表衩衫衬衮衰衲衷衸衹衼衽衾衿袀袁袂袃袄袅袆袇袈袉袊袋袌袍袐袑袒袓袔袕袖袗袘袚袛袜袝袞袟袠袢袣袤袥袦袧袨袩袪被袬袭袱袴袵袷袼袽袿裀裁裂装裆裈裉裋裎裏裒裓裔裕裘裙裛補裝裟裡裢裣裤裥裨裩裯裰裱裲裳裴裶裸裹裺裼製裾褂複褊褋褌褎褏褐褑褒褓褔褙褚褛褜褠褡褣褥褦褧褨褪褫褯褰褱褲褴褵褶褸褹襁襄襆襌襍襕襖襘襛襞襟襢襤襦襪襫襬襱襲襶襻襽襾西要覂覃覅覆覇覈覊見覍規覐覓視覗覙覚覛覟覠覥覩親覯覵覺觀见观规觅视觇览觉觊觋觌觍觎觏觐觑角觓觔觖觚觜觝觞解觥触觫觭觯觱觳觸觼觽觿言訂訃訄訅訆訇計訉訊訋訌討訏訐訑訒訓訔訕託記訙訚訛訜訝訞訟訡訢訣訪設訮許訴訹診註証訽訾詀詄詅詇詈詐詒評詖詗詛詝詞詟詠詢詣詤詥試詧詨詩詪詫詬詭詮詯詰話該詳詵詷詸詹詺詻詼詾詿誇誉誊誌認誓誕誖誘語誠誡誤誥說説誰課誳誴誻誽誾調諂諄諆談諈諉請諏諑諒諓論諘諛諝諠諡諥諦諧諮諱諸諹諺謀謂謄謇謏謚講謝謟謠謡謥謦謧謨謩謪謬謱謴謸謹謺謽謿譁譃譄譅證譌譓譔譗識譜譞譟譢警譫譬譯議護譸譻譽讀讈讉變讌讍讏讓讕讙讚讛讜讝讞讟计订讣认讥讦讧讨让讪讫讬训议讯记讱讲讳讴讵讶讷许讹论讼讽设访诀证诂诃评诅识诇诈诉诊诋诌词诎诏诐译诒诓诔试诖诗诘诙诚诛诜话诞诟诠诡询诣诤该详诧诨诩诪诫诬语诮误诰诱诲诳说诵诶请诸诹诺读诼诽课诿谀谁谂调谄谅谆谇谈谉谊谋谌谍谎谏谐谑谒谓谔谕谖谗谘谙谚谛谜谝谞谟谠谡谢谣谤谥谦谧谨谩谪谫谬谭谮谯谰谱谲谳谴谵谶谷谻谼谽谿豀豁豂豆豇豈豉豊豌豎豐豕豗豚豠象豢豧豨豪豫豬豭豰豳豵豷豸豹豺貂貅貉貊貋貌貍貎貏貐貑貒貓貔貗貘貙貛貝貞負財貢貣貤貦貧貨販貪貫責貮貯貲貴買貸費貼貽貿賀賁賂賄賅資賈賊賓賚賜賞賡賢賣賦賨質賮賯賰賱賲賳賴賷賸賹賺購贀贁贂贄贅贆贇贈贉贊贋贌贏贝贞负贠贡财责贤败账货质贩贪贫贬购贮贯贰贱贲贳贴贵贶贷贸费贺贻贼贽贾贿赀赁赂赃资赅赆赇赈赉赊赋赌赍赎赏赐赑赒赓赔赕赖赗赘赙赚赛赜赝赞赟赠赡赢赣赤赦赧赪赫赭走赲赳赴赵赶起赹赽趁趄超越趋趌趑趔趕趙趝趟趡趣趤趥趦趧趨趩趪趬趮趯趰趱足趴趵趶趷趸趹趺趼趽趾趿跁跂跃跄跅跆跈跉跊跋跌跍跎跏跐跑跒跓跔跖跗跘跚跛距跞跟跡跣跤跨跪跫跬路跰跱跳践跶跷跸跹跺跻跼跽跾踀踃踄踅踆踉踊踌踏踐踔踖踘踝踞踟踡踢踣踥踦踧踨踩踪踫踬踮踯踰踱踴踵踸踹踺踽蹀蹁蹂蹄蹅蹆蹇蹈蹉蹊蹋蹌蹎蹐蹑蹒蹓蹔蹖蹙蹚蹞蹟蹠蹡蹣蹤蹦蹧蹨蹩蹬蹭蹯蹰蹱蹲蹳蹴蹶蹷蹹蹻蹼蹽蹾蹿躁躄躅躇躉躍躏躐躒躔躘躛躜躞躦躩身躬躭躯躱躲躶躺躻躼躿軀軃軅軆軇軈軉車軌軍軎軏軐軒軓軔軘軙軛軟軠軡転軣軧軬軷軸軻軿輀輂較輈載輋輐輒輓輔輕輖輗輘輝輥輦輧輨輩輪輰輳輴輵輶輸輻輽輾輿轂轇轉轋轎轓轕轗轘轝轟轥车轧轨轩轪轫转轭轮软轰轱轲轳轴轵轶轷轸轹轺轻轼载轾轿辀辁辂较辄辅辆辇辈辉辊辋辌辍辎辏辐辑辒输辔辕辖辗辘辙辚辛辜辞辟辢辣辦辨辩辫辭辯辰辱農辵边辻込辽达迁迂迄迅迆过迈迋迍迎迏运近迒迓返迕还这进远违连迟迢迤迥迦迨迩迪迫迭迮迯述迳迴迷迸迹迺迻追退送适逃逄逅逆逇选逊逋逌逍透逐逑递逓途逕逖逗這通逛逝逞速造逡逢連逤逦逭逮逯週進逵逶逷逸逻逼逾逿遁遂遄遆遇遈遊運遍過遏遐遑遒道達違遗遘遙遛遜遝遞遠遡遢遣遥遨適遭遮遯遲遴遵遶遷選遹遺遽避邀邁邂邃還邅邆邇邈邉邊邋邌邏邑邓邔邕邗邘邙邛邝邠邡邢那邥邦邨邪邫邬邮邯邰邱邲邳邴邵邶邸邹邺邻邼邽邾邿郀郁郃郄郅郇郈郊郋郎郏郐郑郓郕郗郘郙郛郜郝郞郟郡郢郤郦郧部郪郫郭郯郴郵郸都郾郿鄂鄄鄉鄍鄑鄗鄘鄙鄚鄛鄜鄞鄟鄠鄡鄢鄣鄤鄦鄧鄩鄫鄬鄮鄯鄰鄱鄳鄶鄷鄹鄺鄽鄿酀酁酂酃酆酇酉酊酋酌配酎酐酒酖酗酚酝酞酡酢酣酤酥酦酨酩酪酬酮酯酰酱酲酳酴酵酶酷酸酹酺酼酽酾酿醁醃醄醅醆醇醉醊醋醌醍醎醐醑醒醕醖醚醛醜醞醡醢醣醥醨醪醫醭醮醯醰醱醲醴醵醺醻醼醽醾醿釀釆采釉释釋里重野量釐金釔釘釙釛釜針釟釠釡釢釣釤釥釦釪釭釱釾釿鈂鈆鈇鈉鈍鈕鈖鈙鈡鈣鈤鈦鈧鈨鈩鈪鈰鈱鈴鈵鈶鈸鈺鈽鈾鈿鉀鉁鉂鉃鉄鉅鉍鉏鉐鉔鉛鉤鉴鉼鉽銀銅銊銌銎銑銒銓銘銙銜銝銦銧銫銮銲銳銶銷鋂鋅鋆鋇鋈鋊鋋鋎鋐鋒鋕鋣鋤鋪鋫鋬鋭鋰鋱鋵鋷鋸鋹鋺鋻鋼鋾錃錄錆錈錋錏錐錗錞錠錢錣錥錦錧錨錫錯録錾鍀鍊鍋鍍鍎鍏鍐鍑鍓鍔鍚鍛鍟鍤鍥鍦鍧鍩鍪鍬鍮鍱鍳鍵鍸鍼鎄鎇鎋鎌鎍鎏鎔鎖鎗鎘鎚鎝鎪鎭鎮鎯鎰鎲鎴鎸鏁鏂鏆鏈鏉鏊鏍鏏鏐鏕鏖鏘鏟鏡鏢鏤鏦鏭鏰鏱鏸鏻鏽鏿鐄鐇鐍鐎鐏鐐鐑鐓鐖鐘鐣鐤鐧鐨鐩鐬鐮鐰鐲鐳鐴鐵鐷鐻鐾鐿鑀鑄鑊鑑鑕鑘鑛鑟鑢鑣鑨鑪鑫鑮鑰鑱鑲鑴鑵鑷鑽鑾鑿钁钃钅钆钇针钉钊钋钌钍钎钏钐钑钒钓钔钕钖钗钘钙钚钛钜钝钞钟钠钡��钣钤钥钦钧钨钩钪钫钬钭钮钯钰钱钲钳钴钵钶钷钸钹钺钻钼钽钾钿铀铁铂铃铄铅铆铈铉铊铋铌铍铎铏铐铑铒铓铔铕铖铗铙铚铛铜铝铞铟铠铡铢铣铤铥铦铧铨铩铪铫铬铭铮铯铰铱铲铳铵银铷铸铹铺铻铼铽链铿销锁锂锃锄锅锆锇锈锉锊锋锌锍锎锏锐锑锒锓锔锕锖锗锘错锚锛锜锝锞锟锡锢锣锤锥锦锧锨锩锪锫锬锭键锯锰锱锲锳锴锵锶锷锸锹锺锻锼锽锾锿镀镁镂镃镄镅镆镇镈镉镊镌镍镎镏镐镑镒镓镔镕镖镗镘镙镚镛镜镝镞镟镠镡镢镣镤镥镦镧镨镩镪镫镬镭镮镯镰镱镲镳镴镵镶長镻长門閃閉開閏閑閒間閔閗閛閟関閣閤閧閬閭閮閯閰閱閳閴閶閷閹閺閻閽閾閿闀闃闄闅闆闇闉闊闌闍闒闕闚闛關闟闡闢门闩闪闫闭问闯闰闱闲闳间闵闶闷闸闹闺闻闼闽闾闿阀阁阂阃阄阅阆阇阈阉阊阋阌阍阎阏阐阑阒阓阔阕阖阗阘阙阚阛阜队阡阢阤阨阪阮阯阱防阳阴阵阶阸阻阼阽阿陀陁陂附际陆陇陈陉陋陌降限陔陕陗陙陛陜陝陞陟陠陡院陣除陧陨险陪陬陮陰陲陳陴陵陶陷陸陻陼陽隂隃隄隅隆隈隊隋隍階随隐隔隗隘隙際障隝隣隤隥隦隧隨隩險隰隱隲隳隶隸隹隺隻隼隽难雀雁雄雅集雇雉雊雋雌雍雎雏雑雒雔雕雖雘雙雚雜雞雟雠離難雨雩雪雮雯雰雱雲雳零雷雹電雾需霁霂霄霅霆震霈霉霍霎霏霑霓霖霘霚霜霝霞霠霣霤霧霨霩霪霫霭霮霰露霳霸霹霾靃靄靈靉青靓靖静靛靜非靠靡面靣靥靦革靭靮靰靱靳靴靵靶靷靸靹靺靼靿鞄鞅鞊鞋鞍鞎鞏鞑鞒鞓鞔鞖鞗鞘鞚鞛鞝鞟鞠鞡鞣鞦鞧鞨鞪鞫鞬鞭鞮鞯鞲鞴鞺鞻鞿韂韆韈韋韌韍韓韗韟韥韦韧韨韩韪韫韬韭韮韰韱韲音韴韵韶韷韺韻韼韽響頁頂頃項順須頉頊頋頌頍頎預頒頓頗領頜頞頠頤頦頨頫頭頰頳頵頷頸頹頺頻顀顆題額顎顏顐顑顒顓顔顕顗願顛顝類顟顣顧顨顩顪顫顬顯顱顳顴页顶顷顸项顺须顼顽顾顿颀颁颂颃预颅领颇颈颉颊颋颌颍颎颏颐频颓颔颖颗题颙颚颛颜额颞颟颠颡颢颤颥颦颧風颩颱颵颺颻颼飀飆风飏飐飑飒飓飔飕飖飗飘飙飚飛飞食飢飥飦飧飨飩飪飭飮飯飰飲飳飷飸飺飼飽飾餀餁餂餃餅餆餇餈餉養餌餍餐餒餓餔餖餗餘餚餟餦館餫餬餮餱餵餼餽饅饆饈饋饌饏饐饑饒饔饕饘饜饝饟饡饤饥饧饨饩饪饫饬饭饮饯饰饱饲饳饴饵饶饷饸饹饺饻饼饽饾饿馀馁馂馃馄馅馆馇馈馉馊馋馍馏馐馑馒馓馔馕首馗馘香馥馧馨馬馮馳馴馻馿駃駉駋駐駕駚駛駜駝駞駡駣駥駨駮駰駳駵駶駷駸駹騁騃騄騇騊騍騎騔騙騛騠騣騧騫騰騷騺騻騼騽騾騿驀驁驂驄驅驆驇驈驊驌驎驑驕驖驗驘驙驚驛驟驡驢驥驦驩马驭驮驯驰驱驳驴驵驶驷驸驹驺驻驼驽驾驿骀骁骂骃骄骅骆骇骈骊骋验骍骎骏骐骑骒骓骔骕骖骗骘骙骚骛骜骝骞骟骠骡骢骣骤骥骧骨骩骫骯骰骱骳骶骷骸骹骺骻骼骾骿髀髁髂髅髆髉髋髌髏髑髒髓體髕高髞髟髠髡髣髤髥髦髧髪髫髭髮髯髲髳髴髹髻髼髽髿鬀鬂鬃鬄鬅鬆鬈鬉鬋鬏鬐鬑鬓鬖鬘鬙鬚鬛鬟鬠鬢鬣鬥鬧鬯鬱鬲鬳鬶鬸鬻鬼鬽鬿魁魂魃魄魅魆魇魈魉魋魍魏魑魒魔魖魚魛魜魟魣魫魰魱魳魵魸魺魽魾魿鮀鮁鮄鮅鮇鮈鮊鮋鮌鮍鮎鮘鮟鮠鮡鮣鮨鮪鮭鮮鮰鮻鮼鮾鯀鯁鯂鯅鯆鯈鯊鯋鯏鯐鯒鯓鯔鯕鯖鯗鯘鯙鯚鯛鯝鯡鯨鯩鯬鯮鯵鯶鯽鰁鰆鰉鰌鰍鰕鰜鰞鰟鰠鰡鰤鰧鰨鰪鰫鰬鰰鰲鰵鰷鰸鰹鰻鰽鰿鱀鱂鱄鱇鱉鱌鱓鱖鱗鱣鱤鱥鱧鱮鱯鱲鱵鱺鱻鱼鱽鱾鱿鲀鲁鲂鲃鲄鲅鲆鲇鲈鲉鲊鲋鲌鲍鲎鲏鲐鲑鲒鲓鲔鲕鲖鲗鲙鲚鲛鲜鲝鲞鲟鲠鲡鲢鲣鲤鲥鲦鲧鲨鲩鲪鲫鲬鲭鲮鲯鲰鲱鲲鲳鲴鲵鲶鲷鲸鲹鲻鲼鲽鲾鲿鳀鳁鳂鳃鳄鳅鳆鳇鳈鳉鳊鳋鳌鳍鳎鳏鳐鳑鳒鳓鳔鳕鳖鳗鳘鳙鳚鳛鳜鳝鳞鳟鳠鳡鳢鳣鳤鳥鳩鳪鳰鳳鳴鳶鳷鳾鳿鴂鴃鴉鴐鴒鴓鴙鴜鴞鴟鴢鴣鴥鴦鴧鴨鴪鴫鴭鴮鴰鴱鴲鴳鴴鴵鴷鴹鴺鴻鴼鴽鴾鴿鵀鵁鵂鵄鵋鵏鵝鵟鵣鵨鵪鵬鵰鵲鵳鵼鶃鶄鶆鶇鶈鶊鶍鶎鶐鶒鶓鶕鶗鶚鶜鶝鶟鶠鶡鶢鶩鶫鶲鶳鶴鶸鶺鷁鷃鷇鷉鷖鷘鷟鷣鷥鷦鷧鷩鷫鷭鷱鷲鷳鷴鷵鷷鷹鷺鷼鷽鷿鸀鸁鸂鸇鸊鸍鸓鸖鸘鸟鸠鸡鸢鸣鸥鸦鸧鸨鸩鸪鸫鸬鸭鸮鸯鸰鸱鸲鸳鸴鸵鸶鸷鸸鸹鸺鸻鸼鸽鸾鸿鹀鹁鹂鹃鹄鹅鹆鹇鹈鹉鹊鹋鹌鹍鹎鹏鹐鹑鹒鹓鹕鹖鹗鹘鹙鹚鹛鹜鹞鹟鹠鹡鹣鹤鹦鹧鹨鹩鹪鹫鹬鹭鹮鹯鹰鹱鹳鹵鹹鹼鹽鹾鹿麀麂麃麄麅麆麇麈麉麊麋麎麏麐麑麒麓麕麖麗麚麜麝麞麟麡麣麤麥麦麧麨麩麯麰麴麵麸麹麻麼麽麾麿黃黄黇黉黋黍黎黏黑黒黔默黛黜黝點黟黠黡黢黥黧黨黩黪黮黯黴黶黹黺黻黼黽黾黿鼂鼄鼅鼇鼈鼉鼊鼋鼍鼎鼏鼐鼑鼓鼖鼗鼘鼙鼜鼞鼠鼢鼤鼥鼩鼪鼫鼬鼮鼯鼰鼱鼶鼷鼹鼻鼾齁齄齆齊齋齏齐齑齒齗齛齜齡齢齣齦齧齮齯齰齲齸齺齻齼齽齾齿龀龁龂龃龄龅龆龇龈龉龊龋龌龍龎龑龒龓龔龙龚龛龜龝龟龠龢龤𢶯秊裏
+The above example starts with a simple sleep bash command that will put your system to sleep for 10 seconds. After that, we combine the previously learned echo command with sleep – this way system will sleep for 10 seconds, then print out some words, sleep again, print out some words again and end its operation.
+Pro Tip
-䰾䲁䲘䴉一上下不且世丟両並中主久之乎也乾亂了予事二互亙些亞亡交享亮亸人什仁今介仍仔他付代令以件任份企伏伐休伙估伴似但佇佈位低住佔何作你佩併使來侖依侮侵侶侷便俁係保俠信修倀倆倉個倍們倒倖候借倣倦倫值偉做停側偵偷偺偽傑傖傘備傚傢傭傯傲傳傴債傷傻傾僂僅僉像僑僕僥僨僱價儀儂億儈儉儐儔儕儘償優儲儷儺儻儼兄充兆兇先光克兌免兒兗入內全兩公共其具冊再冑冒冠冪冷凃凍凜凱出刃分切別利刪到制剄則剋前剎剛剝剩剪剮副割剴創剷劃劇劉劊劌劍劑力功加劣助努効勁勇勉動勗務勚勛勝勞勢勦勩勱勳勵勸勻包化匭匯匱區十千升午半卑卓協博占卡危即卹卻厙原厠厭厲厴去參叄又及友反取受叛叡叢口另只叫召可台史司吃各合吋同名吐向否吧吳吶吹呀呂呃呆告呎呢周呸呼命和咖咼品哇哈哎員哥哦哪哭哼唄唝唯唸啊問啞啟啡啣啦啰啴善喊喚喜喧喪喫喬單嗆嗇嗊嗎嗚嗩嗯嗶嘆嘍嘔嘖嘗嘛嘜嘩嘮嘯嘰嘴嘵嘻嘽嘿噁噓噝噢噥噦器噯噲噴噸噹嚀嚇嚐嚕嚙嚥嚦嚨嚮嚲嚳嚴嚶囀囁囂囅囈囉囊囌囑四回因囪圇國圍園圓圖團土在地圾坐坦坵垃型垯垱埃埋城域埡執培基堅堆堝堪堯報場塆塊塋塏塒塗塚塢塤填塵塹境墊墜增墮墳墶墾壇壋壓壘壙壚壞壟壠壢壩壪士壯壺壽外多夠夢夥大天太夫失夾奇奐奧奩奪奮女奴她奼好如妙妝妨妳始姍姑姦姪姿威娘娛婁婭婳媧媯媼媽嫗嫵嫺嫻嫿嬈嬋嬌嬙嬝嬡嬤嬪嬰嬸孃孌子字存孤孩孫學孿宂它宅宇安完官宙定客宣宮害家容寂寄密富寞寡寢實寧審寫寬寵寶封射將專尊尋對導小少尖就尷尾局屁屃居屆屍屓展屜屢層屨屬岡峣峯峴島峽崍崑崗崙崢嵐嵒嵚嶁嶄嶇嶔嶗嶠嶢嶧嶴嶸嶺嶽巋巒巔巖工巧巨差巰己已巴市希帥師席帳帶常幀幃幗幘幟幣幫幬平年幹幼幾床底度庫庭廁廂廄廈廚廝廟廠廡廢廣廩廬廳延建式弒弔弟弱張強彆彈彌彎彙形彥彩彫影彼往征待很後徑徒得從徠復徬微徹心必忍志忘忙忠快忽怎怕思急性怪恆恐恕恥恨恩息悅您悲悵悶悽情惜惡惱惲想惶惹惻意愚愛愜感愨愴愷愾慄慇慈態慍慘慚慟慢慣慨慪慫慭慮慳慶慷慼慾憂憊憐憑憒憖憚憤憫憮憲憶憾懂懃懇應懌懍懟懣懨懲懶懷懸懺懼懾戀戇成我戔或戧戩戰戲戶所扁手才打扞扭找承技把投抗抱抵抹拆拋拘招拜拭拯拿持指按挑振挺挾捏捕捨捫捲掃掄掉排掙掛採探掣接控推掩揀揍描提揚換揮揹揾搆損搖搗搞搥搧搭搵搶搾摀摃摑摜摟摧摯摳摶摻撈撐撓撕撚撟撣撥撫播撲撳撻撾撿擁擄擇擊擋擔據擠擣擦擬擯擰擱擲擴擷擺擻擼擾攄攆攏攔攖攙攛攜攝攢攣攤攩攪攬支收改攻放故敍救敗敘教敞敢散敬整敵數斂斃文斕料斥斬斯新斷方於施旂旅既日早旸昇明易星是昽時晉晚晝暈暉暗暘暢暫暱曄曆曇曉曖曠曨曬曲更書曾最會月有朋服朗望期朧本朮材束東果枱枴架某染柵柺柿校根格桶桿梔梘條梟梱梲梾梿棁棄棍棒棖棗棚棟棧棲棶楊楓楚楨業極概榦榮榿槃構槍槓槚槜槤槧槨槳樁樂樅樑樓標樞模樣樸樹樺橈橋機橢橫檁檇檉檔檜檟檢檣檯檳檸檻檾櫂櫃櫓櫚櫛櫝櫞櫟櫥櫧櫨櫪櫫櫬櫱櫳櫸櫺櫻欄權欏欒欖次欣欲欺欽款歉歌歎歐歛歟歡止正此步武歲歷歸死歿殆殘殞殤殫殭殮殯殲段殺殼毀毆母每毒比毘毿氂氈氌氣氫氬氳水永氹氾求汎汙汰汲決沄沉沍沒沖沨治況泊法注洩洶活派流浈浐浪浬浹涇消涢涯涼淒淘淚淡淥淨淪深淵淶混淺清渙減渢渣渦測渴渾湊湞湧湯溇溈源準溝溫溳溼滄滅滌滎滓滪滬滯滲滴滸滻滾滿漁漂漊漚漢漣漫漬漲漸漿潁潑潔潛潤潯潰潿澀澆澇澐澗澠澤澦澮澱激濁濃濕濘濛濟濤濫濬濰濱濺濼濾瀅瀆瀉瀋瀏瀕瀘瀝瀟瀠瀦瀧瀨瀰瀲瀾灃灄灑灘灝灣灤灩火灰災炮炸為烈烏烤烴無然煇煉煒煖煙煢煥照煩煬熒熗熱熾燁燄燈燉燐燒燙燜營燦燬燭燴燻燼燾爍爐爛爭父爸爺爾牀牆片牘牠物牲牴特牽犖犛犢犧犯狀狂狗狝狹狽猙猛猶猻獁獄獅獎獨獪獫獮獰獲獵獷獸獺獻獼玀玆率玙玚玡玨玩珮珰現球理琍琎琺琿瑋瑒瑣瑤瑩瑪瑯璉璡璣璦璫環璵璽瓊瓏瓔瓚瓦甌甕甚生產甦用由甲甽界留畢略畫畬異當疇疊疭病痙痛痠痲痳痺瘆瘉瘋瘍瘓瘞瘡瘧瘮瘲瘺療癆癇癉癒癘癟癡癢癤癥癧癩癬癭癮癰癱癲發白百的皚皮皰皸皺盃益盔盡監盤盧目直相眉看真眠眼眾睜睡瞄瞧瞭矓知短石破硜硤硨硯碌碎碟確碼磧礙礪礫礬示社祝神禁禕禮秀私秈科秘移程稚種稱穌穎穠穡空穿突窮窶窺竊立站竟童端競笑笨第筆等答筜筧箇算管節篋篔簀簡簣籃籟籠籩籮粉精��糖糝糟糲糶系糾約紅紆紈紉納紕級紜紡索細紲絀終組絆絎結絕絝絢給統絲綁綃綆綌經綞綢綣綬綯綰網綸綺綻綽綾緇緒緖緘緙緣緬練縉縊縐縑縝縟縭縮縲縵縶總繅繡繪繫繭繰繹繼繽繾纈纊續纓纜缺罌罩罪置罵罷羆羋美群羥羨義習翻翼翽老者而耬耶聊聘聞聯聰聲聳職聽肉肘肚肢肩肯背胎能脅脆腖腡腥腦腳膃膜膝膽膾臂臉臝臠臥自臭至臺與興舉舊舞般船艘艦良艱色芐花芽苦英荷莧菜華萇萌萬落葒著蒐蒓蒔蒙蓀蓄蓋蓽蔓蔭蔹蕆蕎蕕蕢蕩蕪蕭薄薈薊薌薘薟薩薪薺藎藏藥藪藹蘄蘊蘗蘚蘞蘢蘺處虛虧蛋蛺蜂蝦螄螻蟄蟈蟎蟣蟲蟶蠐蠑蠢蠱血衊行術街衛衞衣表袋被袯裊補裡製複褘褳褻襇襏襝襠襯襲襴西要覆見規覓視覘覡覦親覬覲覷覺覽覿觀解觴觶觸言計訊討訓訖託記訥訪設許訴訶詁詆詎詔評詘詡試詭話該誄誅誆誇認誑誓誚誣誤誦誨說誰課誶誹誼調談請諍諒論諗諜諞諢諤諧諫諭諳諶諷諼諾謁謅謊謎謐謔謖謗謙講謝謫謳謾證譎譏譖識譙譚警譭議譴護譾讀變讎讒讓讖豐豔豪貝負財貨貰貳貴貶買貺費賃資賊賑賒賕賞賠賣賤質賫賬賭賽賾贍贏贐贓贔贖贗贛赬走起超越趕趣趲足跑跟路跳踩蹕蹩蹺躂躊躋躑躓躕躚躡躥躪身躲軀車軋軌軍軑軟軤軫軲軹軺軼軾較輅輇載輊輕輛輜輞輟輩輬輯輸轀轄轅轆轉轍轔轟轡轢轤辜辮辱迅迎近返迪迫述迷追退送逃透逐途這通逝逞速造連進逼遇遊運遍過道達違遘遠適遭選遺遼避還邐那邪部郵都鄆鄒鄔鄖鄙鄭鄲鄴酈配酷醒醬釁釃釅采釋重量金釓釕釗釧釩釵釷釹釺鈀鈁鈃鈄鈈鈎鈐鈑鈔鈕鈞鈥鈮鈷鈹鉈鉉鉋鉑鉕鉗鉚鉞鉦鉬鉭鉸鉺鉻鉿銃銍銖銚銠銣銥銨銩銪銬銱銳銹銻銼鋁鋃鋌鋏鋙鋝鋟鋥鋦鋨鋯鋸錁錇錒錕錘錙錚錛錟錡錢錮錯錳錶錸鍁鍃鍆鍇鍘鍠鍰鍶鍺鍾鎂鎊鎖鎛鎡鎢鎣鎦鎧鎩鎬鎮鎳鎵鎿鏃鏌鏑鏗鏜鏝鏞鏡鏨鏵鏷鏹鐃鐋鐒鐔鐙鐝鐠鐦鐫鐸鐺鑌鑒鑔鑞鑠鑥鑭鑹鑼鑽钂铘铴镋長門閂閃閉開閌閎閒間閘閡閣閥閨閩閲閼闈闊闋闐闓闔闖關闞闥防阻附限陘院除陷隉隊隕際障隨險隴雄雅集雇雕雖雙雛雜離難雲零雷電需露霸霽靂靈靚靜非靠面靨革鞀韁韃韉韙韜韞音響頇須頏預頑頓領頡頭頲顆題願顙類顢顥顧顯顰颭颮颯颳颶颸飄飛飫飴飿餄養餎餏餐餑餓餛餜餞餡館餳餶餷餾餿饁饃饉饊饗饞饢馌首馨馬馭馱駁駑駒駔駘駛駟駢駭駱駿騂騅騏騖騙騤騭騮騶騸驃驅驍驏驕驗驚驤驪骨骸體髖高鬆鬍鬥鬧鬨鬩鬮鬼魎魔魘魚魢魨魯魴魷鮃鮐鮑鮓鮫鮶鯇鯉鯢鯤鯧鯪鯫鯴鯷鯿鰃鰈鰏鰓鰛鰣鰥鰩鰭鰱鰳鰺鰾鱅鱈鱒鱔鱘鱝鱟鱠鱭鱷鱸鲺鳥鳲鳴鴆鴇鴕鴛鴝鴯鵃鵐鵑鵒鵓鵜鵠鵡鵮鵯鶉鶘鶥鶯鶹鶻鶼鶿鷂鷊鷓鷗鷙鷚鷯鷸鸌鸏鸕鸚鸛鸝鸞鸤鹝鹲麗麪麻麼麽黌黏默點黷鼓鼕鼴齔齕齙齟齠齪齬齷龐龕
+A bash script can always be terminated by clicking CTRL + C without waiting for it to finish its operation.
+4. Wait Command
-"_—“”‥…‧♪ 、。〃〄々〆〇〈〉《》「」『』【】〒〓〔〕〖〗〘〙〚〛〜〝〞〟〠〡〢〣〤〥〦〧〨〩〪〭〮〯〫〬〰〰︎〰️〱〲〳〴〵〶〷〸〹〺〻〼〽〽︎〽️〾〿・﹁﹂﹏！（），：；？［］｛｝～！。１２３４５６７８９０
+wait is a built-in Linux command that waits for completion of running process. The wait command is used with a particular process id or job id.
-ḉ̣̮̱̀́̂̃̄̆̇̈̊̌̑ΘθΞξΥυΨψΩωϘАаБВвГгДдЕеЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯяЀѐЁёЂђЃѓЄєЅѕІіЇїЈјЉљЊњЋћЌќЍѝЎўЏџѠѡѢѣѤѥѦѧѨѩѪѫѬѭѮѯѰѱѲѳѴѵѶѷѸѹѺѻѼѽѾѿҀҁ҂҃҄҅҆҇҈҉ҊҋҌҍҎҏҐґҒғҔҕҖҗҘҙҚқҜҝҞҟҠҡҢңҤҥҦҧҨҩҪҫҬҭҮүҰұҲҳҴҵҶҷҸҹҺһҼҽҾҿӁӂӃӄӅӆӇӈӉӊӋӌӍӎӀӏӐӑӒӓӔӕӖӗӘәӚӛӜӝӞӟӠӡӢӣӤӥӦӧӨөӪӫӬӭӮӯӰӱӲӳӴӵӶӷӸӹӺӻӼӽӾӿԀԁԂԃԄԅԆԇԈԉԊԋԌԍԎԏԐԑԒԓԔԕԖԗԘԙԚԛԜԝԞԟԠԡԢԣԤԥԦԧԨԩԪԫԬԭԮԯᴫᵸ–⃝◌Ⱛⱛⷠⷡⷢⷣⷤⷥⷦⷧⷨⷩⷪⷫⷬⷭⷮⷯⷰⷱⷲⷳⷴⷵⷶⷷⷸⷹⷺⷻⷼⷽⷾⷿ中文ꙀꙁꙂꙃꙄꙅꙆꙇꙈꙉꙊꙋꙌꙍꙎꙏꙐꙑꙒꙓꙔꙕꙖꙗꙘꙙꙚꙛꙜꙝꙞꙟꙠꙡꙢꙣꙤꙥꙦꙧꙨꙩꙪꙫꙬꙭꙮ꙯꙰꙱꙲꙳ꙴꙵꙶꙷꙸꙹꙺꙻ꙼꙽꙾ꙿꚀꚁꚂꚃꚄꚅꚆꚇꚈꚉꚊꚋꚌꚍꚎꚏꚐꚑꚒꚓꚔꚕꚖꚗꚘꚙꚚꚛꚜб
+Here’s how to create a wait bash script. Begin by creating a new bash file:
-!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿıƒ—‗’“”•‥…‧※≠─│┌┐└┘├┤┬┴┼═║╔╗╚╝��╣╦╩╬▀▄█░▒▓■♪ 、。〃〄々〆〇〈〉《》「」『』【】〒〓〔〕〖〗〘〙〚〛〜〝〞〟〠〡〢〣〤〥〦〧〨〩〪〭〮〯〫〬〰〱〲〳〴〵〶〷〸〹〺〻〼〽〾〿ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわゐゑをんゔゕゖ゙゚゛゜ゝゞゟァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾタダチヂッツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポマミムメモャヤュユョヨラリルレロワヰヱヲンヴヶ・ーㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ一丁七万丈三上下不与且世丘丙両並丨中串丶丸丹主丼丿久乏乗乘乙九乞乱乳乾亀亂亅了予争事二互五井亜亞亠亡交享京亭人仁今介仏仕他付仙代令以仮仰仲件任企伎伏伐休会伝伯伴伸伺似但位低住佐体何余佛作佳併使來例侍供依価侮侯侵侶便係促俊俗保信修俳俵俸俺倂倉個倍倒候借倣値倫倹假偉偏停健側偵偶偽傍傑傘備催傲傳債傷傾僅働像僕僚僞僧價儀億儉儒償優儿元兄充兆先光克免児兒党入全兩八公六共兵具典兼冂内円冊再冒冖冗写冠冥冫冬冶冷凄准凍凝几凡処凵凶凸凹出刀刃分切刈刊刑列初判別利到制刷券刹刺刻則削前剖剛剝剣剤剩副剰割創劇劍劑力功加劣助努励労効劾勃勅勇勉動勘務勝勞募勢勤勧勲勳勵勸勹勾匂包匕化北匚匠匸匹区医匿區十千升午半卑卒卓協南単博卜占卩印危即却卵卷卸卽厂厄厘厚原厳厶去参參又及友双反収叔取受叙口古句叩叫召可台史右号司各合吉同名后吏吐向君吟否含吸吹呂呈呉告周呪味呼命和咲咽哀品員哲哺唄唆唇唐唯唱唾商問啓善喉喚喜喝喩喪喫單営嗅嗣嘆嘱嘲噂器噴嚇嚴囑囗囚四回因団困囲図固国圈國圍圏園圓圖團土圧在地坂均坊坑坪垂型垣埋城域執培基埼堀堂堅堆堕堤堪報場堵塀塁塊塑塔塗塚塞塡塩塵塾境墓増墜增墨墮墳墾壁壇壊壌壓壘壞壤士壮壯声壱売壹壽変夊夏夕外多夜夢大天太夫央失奇奈奉奏契奔奥奧奨奪奬奮女奴好如妃妄妊妖妙妥妨妬妹妻姉始姓委姫姻姿威娘娠娯婆婚婦婿媒媛嫁嫉嫌嫡嬢孃子孔字存孝季孤学孫學宀宅宇守安完宗官宙定宛宜宝実客宣室宮宰害宴宵家容宿寂寄密富寒寛寝察寡寢實寧審寫寬寮寶寸寺対寿封専射将將專尉尊尋對導小少尚尢就尸尺尻尼尽尾尿局居屆屈届屋屑展属層履屬屮屯山岐岡岩岬岳岸峠峡峰島峽崇崎崖崩嵐嶽巛川州巡巢巣工左巧巨差己巻巾市布帆希帝帥師席帯帰帳帶常帽幅幕幣干平年幸幹幺幻幼幽幾广庁広床序底店府度座庫庭庶康庸廃廉廊廢廣廳廴延廷建廾弁弄弊弋式弐弓弔引弟弥弦弧弱張強弾彈彌彐当彙彡形彩彫彰影彳役彼往征径待徊律後徐徑徒従得徘從御復循微徳徴徵德徹心必忌忍志忘忙応忠快念怒怖思怠急性怨怪恆恋恐恒恣恥恨恩恭息恵悔悟悠患悦悩悪悲悼情惑惚惜惠惡惧惨惰惱想愁愉意愚愛感愼慄慈態慌慎慕慘慢慣慨慮慰慶憂憎憤憧憩憬憲憶憾懇應懐懲懷懸戀戈成我戒戚戦戯戰戲戴戶戸戻戾房所扇扉手才打払扱扶批承技抄把抑投抗折抜択披抱抵抹押抽拂担拉拍拐拒拓拔拘拙招拜拝拠拡括拭拳拶拷拾持指挑挙挟挨挫振挾挿捉捕捗捜捨据捻掃授掌排掘掛採探接控推措掲描提插揚換握揭揮援揺損搖搜搬搭携搾摂摘摩摯撃撤撮撲擁擇擊操擔據擢擦擧擬擴攝支攴收改攻放政故效敍敏救敕敗教敢散敬数整敵敷數文斉斎斐斑斗料斜斤斥斬断新斷方施旅旋族旗无既日旦旧旨早旬旺昆昇明易昔星映春昧昨昭是昼時晚晝晩普景晰晴晶暁暇暑暖暗暦暫暮暴曆曇曉曖曜曰曲更書曹曽曾替最會月有服朕朗望朝期木未末本札朱朴机朽杉材村束条来杯東松板析枕林枚果枝枠枢枯架柄某染柔柱柳柵査柿栃栄栓校株核根格栽桁桃案桑桜桟梅梗條梨械棄棋棒棚棟棧森棺椅植椎検業極楷楼楽概榮構様槪槽樂樓標樞模樣権横樹橋機橫檢櫻欄權欠次欧欲欺款歌歐歓歡止正步武歩歯歳歴歷歸歹死殉殊残殖殘殳殴段殺殻殼殿毀毆毋母毎每毒比毛氏民气気氣水氷永氾汁求汎汗汚江池汰決汽沃沈沒沖沙没沢河沸油治沼沿況泉泊泌法泡波泣泥注泰泳洋洗洞津洪活派流浄浅浜浦浪浮浴海浸消涉涙涜涯液涼淑淚淡淨淫深混淺添清渇済渉渋渓減渡渦温測港渴湖湧湯湾湿満源準溜溝溪溫溶溺滅滋滑滝滞滯滴滿漁漂漆漏演漠漢漫漬漸潔潛潜潟潤潮潰澁澄澤激濁濃濕濟濫濯濱瀧瀨瀬灣火灯灰災炉炊炎炭点為烈無焦然焼煎煙照煩煮熊熟熱燃燈燒營燥爆爐爪爭爲爵父爻爽片版牙牛牧物���特犠犧犬犯状狀狂狙狩独狭狹猛猟猫献猶猿獄獣獨獲獵獸獻玄率玉王玩珍珠班現球理琴瑠璃璧環璽瓜瓣瓦瓶甁甘甚生産用田由甲申男町画界畏畑畔留畜畝略番畫異畳當畿疊疋疎疑疒疫疲疾病症痕痘痛痢痩痴瘍瘦療癒癖癡癶発登發白百的皆皇皮皿盆益盗盛盜盟盡監盤目盲直相盾省眉看県眞真眠眺眼着睡督睦瞬瞭瞳矛矢知短矯石砂研砕砲破硏硝硫硬碁碎碑確磁磨礁礎示礼社祈祉祕祖祝神祥票祭禁禅禍福禪禮禾秀私秋科秒秘租秩称移程税稚種稱稲稻稼稽稿穀穂積穏穗穩穫穴究空突窃窒窓窟窮窯竊立竜竝章童端競竹笑笛符第筆等筋筒答策箇箋算管箱箸節範築篤簡簿籍籠米粉粋粒粗粘粛粧粹精糖糧糸系糾紀約紅紋納純紙級紛素紡索紫累細紳紹紺終組経結絕絞絡給統絲絵絶絹經継続綠維綱網綻綿緊総緑緒緖線締緣編緩緯練緻縁縄縛縣縦縫縮縱總績繁繊繋織繕繩繪繭繰繼續纖缶缺罐网罠罪置罰署罵罷羅羊美羞群羨義羽翁翌習翻翼老考者而耐耒耕耗耳聖聞聲聴職聽聿肅肉肌肖肘肝股肢肥肩肪肯育肺胃胆背胎胞胴胸能脂脅脇脈脊脚脱脳腎腐腕腦腫腰腸腹腺膚膜膝膨膳膽臆臓臟臣臨自臭至致臺臼與興舊舌舍舎舗舛舞舟航般舶舷船艇艦艮良色艶艷艸芋芝芯花芳芸芽苗苛若苦英茂茎茨茶草荒荘荷莊莖菊菌菓菜華萎萬落葉著葛葬蒸蓄蓋蔑蔵蔽薄薦薪薫薬薰藍藏藝藤藥藩藻虍虎虐處虚虛虜虞號虫虹蚊蚕蛇蛍蛮蜂蜜融螢蟲蠶蠻血衆行術街衛衝衞衡衣表衰衷袋袖被裁裂装裏裕補裝裸製裾複褐褒襃襟襲襾西要覆覇見規視覚覧親観覺覽觀角解触觸言訂訃計討訓託記訟訪設許訳訴診証詐詔評詞詠詣試詩詮詰話該詳誇誉誌認誓誕誘語誠誤説読誰課調談請論諦諧諭諮諸諾謀謁謄謎謙講謝謠謡謹證識譜警譯議譲護譽讀變讓谷豆豊豐豕豚象豪豫豸貌貝貞負財貢貧貨販貪貫責貯貳貴買貸費貼貿賀賂賃賄資賊賓賛賜賞賠賢賣賦質賭賴購贈贊赤赦走赴起超越趣足距跡路跳践踊踏踐踪蹴躍身車軌軍軒軟転軸軽較載輕輝輩輪輸轄轉辛辞辣辨辭辯辰辱農辵辺込辿迅迎近返迫迭述迷追退送逃逆透逐逓途通逝速造連逮週進逸遂遅遇遊運遍過道達違遜遞遠遡遣適遭遮遲遵遷選遺避還邊邑那邦邪邸郊郎郞郡部郭郵郷都鄕酉酌配酎酒酔酢酪酬酵酷酸醉醒醜醫醸釀釆采釈釋里重野量金釜針釣鈍鈴鉄鉛鉢鉱銀銃銅銘銭鋭鋳鋼錄錠錢錦錬錮錯録鍊鍋鍛鍵鎌鎖鎭鎮鏡鐘鐵鑄鑑鑛長門閉開閑間関閣閥閲闇闘關阜阪防阻附降限陛院陣除陥陪陰陳陵陶陷陸険陽隅隆隊階随隔隙際障隠隣隨險隱隶隷隹隻雄雅集雇雌雑雙雜離難雨雪雰雲零雷電需震霊霜霧露霸靈靑青静靜非面革靴韋韓音韻響頁頂頃項順須預頑頒頓領頭頰頻頼題額顎顔顕願類顧顯風飛飜食飢飯飲飼飽飾餅養餌餓餘餠館首香馬駄駅駆駐駒騎騒験騰騷驅驗驚驛骨骸髄髓體高髟髪髮鬥鬭鬯鬱鬼魂魅魔魚鮮鯨鳥鳴鶏鶴鷄鹵鹽鹿麓麗麥麦麵麺麻黃黄黑黒默黙點黨鼓鼻齊齋齒齡齢龍龜𠠀欄廊朗虜殺類隆塚神祥福諸都侮僧免勉勤卑喝嘆器塀墨層悔慨憎懲敏既暑梅海漢煮碑社祉祈祖祝禍穀突節練繁署者臭著褐視謁謹賓贈逸難響頻︎️﹁﹂﹏！（），０１２３４５６７８９：；？［］｛｝～･ｦｧｨｩｪｫｬｭｮｯｰｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝﾞﾟ�
+nano wait.sh
-ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎㅏㅐㅑㅓㅔㅕㅗㅘㅛㅜㅠㅡㅢㅣㅿㆁㆆㆍ가각갂간갇갈갉감갑값갓갔강갖갗같갚갛개객갠갤갬갭갯갰갱갸갹걀걔거걱건걷걸걹검겁것겄겅겆겉겊겋게겐겔겜겟겠겡겨격겪견겯결겸겹겼경곁계곗고곡곤곧골곪곬곯곰곱곳공곶곺과곽관괄괌괍괏광괘괙괜괠괨괩괭괴괵괸괼굄굉교구국군굳굴굵굶굻굼굽굿궁궂궈궉권궐궝궤궹귀귄귈귐귑귓귕규균귤귬그극근귿글긁긇금급긋긍긎긏긑긔기긱긴긷길김깁깃깄깅깊까깍깎깐깔깜깝깟깠깡깢깥깨깩깬깰깸깹깻깼깽꺄꺅꺼꺽꺾껀껄껌껍껏껐껑께껜껭껴꼉꼍꼬꼭꼰꼴꼼꼽꼿꽁꽂꽃꽈꽉꽌꽐꽘꽜꽝꽤꽥꽹꾀꾄꾈꾐꾕꾜꾸꾹꾼꾿꿀꿇꿈꿉꿋꿍꿎꿔꿘꿩꿰뀀뀌뀍뀐뀔뀜뀝뀨끄끅끈끊끌끓끔끕끗끙끝끠끼끽낀낄낌낍낏낐낑나낙낚난낟날낡남납낫났낭낮낯낱낳내낵낸낻낼냄냅냇냈냉냐냑냠냥냬너넉넋넌넏널넓넘넙넛넜넝넞넣네넥넨넬넴넵넷녀녁년념녑녓녔녕녘녜노녹녺논놀놈놉놋농높놓놔놨뇌뇐뇔뇜뇨뇽누눅눈눋눌눓눔눕눗눠눳눴뉘뉜뉠뉨뉩뉴늄늉느늑는늘늙늠늡능늦늪늬니닉닌닐님닙닛닝닢다닥닦단닫달닭닮닳담답닷당닺닻닿대댁댄댈댐댑댓댔댕더덕던덛��덟덤덥덧덨덩덪덫덮데덱덴델뎀뎃뎅뎌도독돈돋돌돐돔돕돗동돛돼됀됐되된될됨됩됫됬두둑둔둘둠둡둣둥둬뒀뒈뒤뒷듀듈듐드득든듣들듬듭듯등디딕딘딛딜딤딥딧딨딩딪따딱딲딴딷딸땀땁땃땄땅땋때땍땐땔땜땝땟땠땡떠떡떤떨떫떰떱떳떴떵떻떼뗀뗄뗌뗏뗑또똑똔똘똥뙤뚜뚝뚤뚫뚬뚱뛰뛴뛸뜀뜁뜨뜩뜬뜯뜰뜸뜹뜻띄띈띠띤띨띰띱띵라락란랄람랍랏랐랑랗래랙랜랠램랩랫랬랭랴략량러럭런럴럼럽럿렀렁렇레렉렌렐렘렙렛렝려력련렬렴렵렷렸령례로록론롤롬롭롯롱뢰료룡루룩룬룰룸룹룻룽뤄뤼류륙륜률륨륭르륵른를름릅릇릉릎리릭린릴림립릿링맄마막만많맏말맑맘맙맛망맞맡맣매맥맨맬맴맵맷맸맹맺먀머먹먼멀멈멉멋멍멎멓메멕멘멜멤멥멧며멱면멸몃몄명몇모목몫몬몰몸몹못몽뫃뫼묏묘무묵묶문묻물묽뭄뭇뭉뭍뭏뭐뭔뭘뭡뭣뮈뮌뮤뮬뮴므믄믈믐미믹민믿밀밈밉밋밌밍및밑바박밖반받발밝밟밤밥밧방밭배백밴밷밸뱀뱁뱃뱄뱅버벅번벋벌범법벗벘벙벚베벡벤벧벨벰벱벳벵벼벽변별볌볍볏볐병볒볕보복볶본볼봄봅봇봉봐봔봤뵈뵉뵌뵐뵘뵙뵤부북분붇불붉붐붑붓붕붙붜뷔뷰브븍븐블븜븝븟비빅빈빋빌빎빔빕빗빙빚빛빠빡빤빨빰빱빳빴빵빻빼빽뺀뺄뺌뺏뺐뺑뺘뺨뻐뻑뻔뻗뻘뻠뻣뻤뻥뻬뼈뼉뼘뼝뽀뽁뽄뽈뽐뽑뽕뾰뿀뿅뿌뿍뿐뿔뿜뿝뿡쁘쁙쁜쁠쁨쁩삐삑삔삘삠삣삥사삭삮삯산삳살삵삶삼삽삿샀상샅새색샌샏샐샘샙샛샜생샤샥샨샬샴샷샹서석섞선섣설섥섦섧섪섬섭섯섰성섶세섹센셀셈셉셋셍셑셔션셜셧셨셰소속솎손솔솜솝솟송솥솨솩솰쇄쇈쇗쇠쇤쇨쇰쇱쇳쇼쇽숀숄숍수숙순숟술숨숩숫숭숯숱숲숴쉐쉘쉬쉰쉴쉼쉽쉿슁슈슉슐슘슛슝스슥슨슬슭슴습슷승시식신싣실싫심십싯싱싶싸싹싼쌀쌈쌉쌋쌌쌍쌓쌔쌕쌘쌜쌤쌧쌨쌩쌰썃썅써썩썬썰썲썸썹썼썽쎄쎈쎙쏘쏙쏜쏟쏠쏨쏭쏴쏵쐐쐬쐰쐴쐼쐿쑤쑥쑨쑬쑴쑹쒀쒔쓔쓕쓰쓱쓴쓸씀씁씌씐씨씩씬씰씸씹씻씽아악안앉않알앍앎앏앒앓암압앗았앙앞앟애액앤앨앰앱앳앴앵야약얀얄얇얌얍얏얐양얕얗얘얜얫얱어억얶언얹얺얻얼얽엄업없엇었엉엊엌엎에엑엔엘엠엡엣엥여역엮연열엶엷염엽엾엿였영옆옇예옌옐옛옜옝오옥온올옭옮옳옴옵옷옹옺옻와왁완왈왐왑왓왔왕왜왝왠왱외왹왼욀욈욋욍요욕욘욥욧용우욱운욷울욹욺움웁웃웅워웍원월웜웝웟웠웡웨웩웬웰웸웹웽위윅윈윌윔윗윙유육윤율윰윳융윷으윽은을읊음읍응의이익인일읽잃임입잇있잉잊잎자작잔잖잘잠잡잣잤장잦잧재잭잰잴잼잽잿쟀쟁쟈쟉쟌쟘저적전절젊점접젓젔정젖제젝젠젤젬젭젯져젼졌조족존졸졺좀좁종좆좇좋좌좍좐좔좜좝좟좠좨좬좰좸죄죈죌죔죕죗죠죤죰죱죵주죽준줄줆줌줍줏중줘줬쥐쥔쥘쥠쥡쥬쥰쥴즈즉즌즐즘즙증지직진짇질짊짐집짓징짖짙짚짜짝짠짢짤짧짬짭짯짰짱째짹짼쨀쨈쨉쨋쨌쨍쨘쩌쩍쩐쩔쩜쩝쩡쪄쪘쪼쪽쫀쫄쫌쫍쫑쫒쫓쫘쫙쬐쬔쬘쬠쬡쭁쭈쭉쭌쭐쭘쭙쭝쭤쮸쯔쯤쯧찌찍찐찔찜찝찡찢찧차착찬찮찯찰참찹찻찼창찾찿채책챈챌챔챕챘챙챠챤챰챱처척천철첨첩첫청체첵첸첼쳇쳐쳤초촉촌촐촘촙촛총촬최쵸추축춘출춤춥춧충춰췄췌취츄츠측츰층치칙친칠칡침칩칫칭카칵칸칼캄캅캇캉캐캑캔캘캠캡캣캥캬캭커컨컬컴컵컷컹케켁켄켈켐켑켓켕켜켠켤켬켭켯켰코콕콘콜콤콥콧콩콰콱콴콸쾀쾅쾌쾍쾡쾰쿄쿠쿡쿤쿨쿰쿳쿵쿼퀘퀭퀴퀵퀸큐크큭큰클큼큽킁키킥킨킬킴킵킷킹타탁탄탈탉탐탑탓탔탕태택탠탤탬탭탯탰탱터턱턴털텀텁텃텄텅테텍텐텔템텝텟텠텡텨토톡톤톨톰톱톳통퇘퇴퇸투툭툰툴툼툽툿퉁퉤퉷튀튄튈튐튑튓튕튜튬트특튼튿틀틈틉틋틔티틱틴틸팀팁팅파팍팎판팔팜팝팟팠팡팥패팩팬팰팸팹팻팼팽퍼퍽펀펄펌펍펏펐펑페펙펜펠펨펩펫펭펴펵편펼폄폅폈평폐포폭폰폴폼폽폿퐁푀푄표푯푸푹푼풀품풉풋풍퓌퓨프픈플픔픕피픽핀필핌핍핏핑하학한할핥함합핫핬항핱해핵핸핼햄햅햇했행햐향허헉헌헐헒험헙헛헝헤헥헨헬헴헵헷헹혀혁현혈혐협혓혔형혜호혹혼홀홈홉홋홍화확환활홧황홰홱횃회획횟횡효후훅훈훌훑훔훗훠훤훨훰훼휀휑휘휙휜휠휨휩휭휴휼흄흉흐흑흔흗흘흙흠흡흣흥흩희흰흴히힉힌힐힘힙힛힝︎️
+Paste in the following:
-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ÆⱭÐƎƏƐƔIJƖŊŒƆƱ‘ẞÞƲǷȜƷʔæɑðǝəɛɣıijɩŋœɔʊĸſßþʋƿȝʒôĄ̧ƁÇĐƊƉĘȨƑǤĦꞪĮƗƘŁƝǪØƠɌŞŢŦŲƯɄ̨ƳąɓçđɗɖęȩƒǥħɦįɨƙłɲǫøơɍşţŧųưʉƴäëÁÀÂÄǍĂĀÃÅǺǼǢĆĊĈČĎḌÉÈĖÊËĚĔĒẼẸĠĜǦĞ̃ĢáàâǎăāãåǻǽǣćċĉčďḍéèėêěĕēẽẹġĝǧğģíüõĤḤÍÌİÎÏǏĬĪĨỊĴĶǨĹĻĽĿʼŃ̈ŇÑŅÓÒÔÖǑŎŌÕŐỌǾĥḥìîïǐĭīĩịĵķǩĺļľŀʼnńňñņóòöǒŏōőọǿḶŔŘŖŚŜŠȘṢŤȚṬÚÙÛÜǓŬŪŨŰŮỤẂẀŴẄÝỲŶŸȲỸŹŻŽẒǮŕřŗśŝšșṣťțṭúùûǔŭūũűůụẃẁŵẅýỳŷÿȳỹźżžẓǯ
+#!/bin/bash
+wait 1234
+echo “Done”
-!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`AaBbCcDdEeFfGgHhIiİJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz{|}~¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿×ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêËëÌìÍíÎîÏïÐðÑñÒòÓóÔôÕõÖö÷ØøÙùÚúÛûÜüÝýÞþÿŸĀāĂ㥹ĆćĊċČčĎďĒēĖėĘęĚěĞğĠġĢģĦħĪīĮįıIJijĶķĹĺĻļĽľŁłŃńŅņŇňŐőŒœŔŕŘřŚśŞşŠšŤťŪūŮůŰűŲųŹźŻżŽžƒDždžDzdzȚțˇ˘˙˛˜;΄΅·ΐΆάΈέΉήΊίΰΑαΒβΓγΔδΕεΖζΗηΘθΙιΚκΛλΜμΝνΞξΟοΠπΡρςΣσΤτΥυΦφΧχΨψΩωΪϊΫϋΌόΎύΏώАаБбВвГгДдЕеЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯяЁё–—‘‚‛“”„†‡•…‰′″‹›※€№™←↑→↓⇒⇔∀∂√∞∴∵⊂⊃⌒■□▲△▼▽◆◇○◎●★☆♀♂♪♭ 、。〃々〆「」『』【】〒ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわをんゝゞァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾタダチヂッツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポマミムメモャヤュユョヨラリルレロヮワヲンヴヵヶ・ー仝！？～
+Important! If no job ID is provided, the wait command waits until all child background jobs are completed.
+5. Comments
+Users can easily add comments to their bash scripts with the # symbol. It is extra useful if you’ve got a lengthy script that needs explaining on some lines.
+Begin by creating a new bash script:
-repo_name,path,size,content,license
-gameclosure/jsiohint,tests/cli.js,37060,"""use strict"";
+nano comments.sh
-var path = require(""path"");
-var shjs = require(""shelljs"");
-var sinon = require(""sinon"");
+Then paste in the following:
-var cliPath = path.resolve(__dirname, ""../src/cli.js"");
-var cli;
+#!/bin/bash
+# Define a variable named Hostinger
+provider="Hostinger"
+# Print out the following text
+echo 'The best hosting provider is $provider'
+# Print out the following text with $provider variable value
+echo "The best hosting provider is $provider"
-exports.setUp = function(done) {
- this.sinon = sinon.sandbox.create();
+The command-line window showing single line comment functionality. It's worth noting that bash comments are not displayed with the script output.
- // The CLI module maintains some internal state in order to optimize
- // filesystem operations. This state can lead to undesirable test case
- // interdependencies. While re-loading the CLI module for every test may
- // negatively effect the execution time of this test suite, it is the most
- // maintainable way to avoid any current or future problems relating to
- // shared internal state.
- cli = require(""../src/cli.js"");
+Keep in mind that bash comments are only visible on a text editor.
+6. Get User Input
- done();
-};
+To take input from users, we’ll use the read bash command. First, create a new bash shell file:
-exports.tearDown = function(done) {
- this.sinon.restore();
+nano read.sh
- cli = null;
- delete require.cache[cliPath];
+Then, fill it with the script below:
- done();
-};
+#!/bin/bash
+echo "What is your age?"
+read age
+echo "Wow, you look younger than $age years old"
-exports.group = {
- setUp: function (cb) {
- this.sinon.stub(cli, ""exit"");
- cb();
- },
+In the above example, an age value was entered by the user. The output was then printed via the echo command.
+7. Loops
- config: {
- setUp: function (done) {
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file\.js$/))
- .returns(""var a = function () {}; a();"")
- .withArgs(sinon.match(/file1\.json$/))
- .returns(""wat"")
- .withArgs(sinon.match(/file2\.json$/))
- .returns(""{\""node\"":true,\""globals\"":{\""foo\"":true,\""bar\"":true}}"")
- .withArgs(sinon.match(/file4\.json$/))
- .returns(""{\""extends\"":\""file3.json\""}"")
- .withArgs(sinon.match(/file5\.json$/))
- .returns(""{\""extends\"":\""file2.json\""}"")
- .withArgs(sinon.match(/file6\.json$/))
- .returns(""{\""extends\"":\""file2.json\"",\""node\"":false}"")
- .withArgs(sinon.match(/file7\.json$/))
- .returns(""{\""extends\"":\""file2.json\"",\""globals\"":{\""bar\"":false,\""baz\"":true}}"")
- .withArgs(sinon.match(/file8\.json$/)).returns(JSON.stringify({
- extends: ""file7.json"",
- overrides: {
- ""file.js"": {
- globals: {
- foo: true,
- bar: true
- }
- }
- }
- }))
- .withArgs(sinon.match(/file9\.json$/)).returns(JSON.stringify({
- extends: ""file8.json"",
- overrides: {
- ""file.js"": {
- globals: {
- baz: true,
- bar: false
- }
- }
- }
- }));
-
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/file1\.json$/)).returns(true)
- .withArgs(""-e"", sinon.match(/file2\.json$/)).returns(true)
- .withArgs(""-e"", sinon.match(/file3\.json$/)).returns(false)
- .withArgs(""-e"", sinon.match(/file4\.json$/)).returns(true)
- .withArgs(""-e"", sinon.match(/file5\.json$/)).returns(true)
- .withArgs(""-e"", sinon.match(/file6\.json$/)).returns(true);
-
- var _cli = require(""cli"");
- this.out = this.sinon.stub(_cli, ""error"");
-
- done();
- },
+A loop is an essential tool in various programming languages. To put it simply, a bash loop is a set of instructions that are repeated until a user-specified condition is reached. Start by creating a loop bash program:
- normal: function (test) {
- this.sinon.stub(cli, ""run"").returns(true);
-
- // Merges existing valid files
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file5.json""
- ]);
- test.equal(cli.run.lastCall.args[0].config.node, true);
- test.equal(cli.run.lastCall.args[0].config['extends'], void 0);
-
- // Overwrites options after extending
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file6.json""
- ]);
- test.equal(cli.run.lastCall.args[0].config.node, false);
-
- // Valid config
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file2.json""
- ]);
-
- // Performs a deep merge of configuration
- cli.interpret([
- ""node"", ""jshint"", ""file2.js"", ""--config"", ""file7.json""
- ]);
- test.deepEqual(cli.run.lastCall.args[0].config.globals, { foo: true, bar: false, baz: true });
-
- // Performs a deep merge of configuration with overrides
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file8.json""
- ]);
- test.deepEqual(cli.run.lastCall.args[0].config.overrides[""file.js""].globals, { foo: true, bar: true });
-
- // Performs a deep merge of configuration with overrides for the same glob
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file9.json""
- ]);
- test.deepEqual(cli.run.lastCall.args[0].config.overrides[""file.js""].globals, { foo: true, bar: false, baz: true });
-
- test.done();
- },
+nano whileloop.sh
- failure: function (test) {
- var out = this.out;
- cli.exit.throws(""ProcessExit"");
-
- // File doesn't exist.
- try {
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file3.json""
- ]);
- } catch (err) {
- var msg = out.args[0][0];
- test.equal(msg.slice(0, 23), ""Can't find config file:"");
- test.equal(msg.slice(msg.length - 10), ""file3.json"");
- test.equal(err, ""ProcessExit"");
- }
+Then paste in the following:
- // Invalid config
- try {
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file1.json""
- ]);
- } catch (err) {
- var msg = out.args[1][0];
- test.equal(msg.slice(0, 24), ""Can't parse config file:"");
- test.equal(msg.slice(25, 35), ""file1.json"");
- test.equal(msg.slice(msg.length - 37), ""Error:SyntaxError: Unexpected token w"");
- test.equal(err, ""ProcessExit"");
- }
+#!/bin/bash
+n=0
+while :
+do
+echo Countdown: $n
+((n++))
+done
- // Invalid merged filed
- try {
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""file4.json""
- ]);
- } catch (err) {
- var msg = out.args[2][0];
- test.equal(msg.slice(0, 23), ""Can't find config file:"");
- test.equal(msg.slice(msg.length - 10), ""file3.json"");
- test.equal(err, ""ProcessExit"");
- }
+This will work as a countdown to infinity until you press CTRL + C to stop the script.
+Now that we’ve tested the while loop, we can move on to the for loop. Create a bash file for it:
- test.done();
- }
- },
+nano forloop.sh
- testPrereq: function (test) {
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file\.js$/)).returns(""a();"")
- .withArgs(sinon.match(/prereq.js$/)).returns(""var a = 1;"")
- .withArgs(sinon.match(/config.json$/))
- .returns(""{\""undef\"":true,\""prereq\"":[\""prereq.js\"", \""prereq2.js\""]}"");
+It should contain the script below:
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/prereq.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/config.json$/)).returns(true);
+#!/bin/bash
+for (( n=2; n<=10; n++ ))
+do
+echo "$n seconds"
+done
- cli.exit.withArgs(0).returns(true)
- .withArgs(2).throws(""ProcessExit"");
+A bash script showcasing the "for" loop
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--config"", ""config.json""
- ]);
+The script prints out numbers from 2 to 10 while adding the seconds keyword to it.
+8. Create an Array
- shjs.cat.restore();
- shjs.test.restore();
+A bash array is a data structure designed to store information in an indexed way. It is extra useful if users need to store and retrieve thousands of pieces of data fast. What makes bash arrays special is that unlike any other programming language, they can store different types of elements. For example, you can use a bash array to store both strings and numbers.
- test.done();
- },
+Create a new file in the current directory:
- // CLI prereqs
- testPrereqCLIOption: function (test) {
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file\.js$/)).returns(""a();"")
- .withArgs(sinon.match(/prereq.js$/)).returns(""var a = 1;"")
- .withArgs(sinon.match(/config.json$/)).returns(""{\""undef\"":true}"");
-
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/prereq.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/config.json$/)).returns(true);
-
- cli.exit.restore();
- this.sinon.stub(cli, ""exit"")
- .withArgs(0).returns(true)
- .withArgs(2).throws(""ProcessExit"");
-
- cli.interpret([
- ""node"", ""jshint"", ""file.js"",
- ""--config"", ""config.json"",
- ""--prereq"", ""prereq.js , prereq2.js""
- ]);
-
- shjs.cat.restore();
- shjs.test.restore();
-
- test.done();
- },
+nano array.sh
- // CLI prereqs should get merged with config prereqs
- testPrereqBothConfigAndCLIOption: function (test) {
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file\.js$/)).returns(""a(); b();"")
- .withArgs(sinon.match(/prereq.js$/)).returns(""var a = 1;"")
- .withArgs(sinon.match(/prereq2.js$/)).returns(""var b = 2;"")
- .withArgs(sinon.match(/config.json$/))
- .returns(""{\""undef\"":true,\""prereq\"":[\""prereq.js\""]}"");
-
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/prereq.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/prereq2.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/config.json$/)).returns(true);
-
- cli.exit.restore();
- this.sinon.stub(cli, ""exit"")
- .withArgs(0).returns(true)
- .withArgs(2).throws(""ProcessExit"");
-
- cli.interpret([
- ""node"", ""jshint"", ""file.js"",
- ""--config"", ""config.json"",
- ""--prereq"", ""prereq2.js,prereq3.js""
- ]);
-
- shjs.cat.restore();
- shjs.test.restore();
-
- test.done();
- },
+Combine the freshly learned for loop with a new indexed array:
- testOverrides: function (test) {
- var dir = __dirname + ""/../examples/"";
- var rep = require(""../examples/reporter.js"");
- var config = {
- ""asi"": true,
- ""overrides"": {
- ""bar.js"": {
- ""asi"": false
- }
- }
- };
-
- this.sinon.stub(process, ""cwd"").returns(dir);
- this.sinon.stub(rep, ""reporter"");
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/foo\.js$/)).returns(""a()"")
- .withArgs(sinon.match(/bar\.js$/)).returns(""a()"")
- .withArgs(sinon.match(/config\.json$/))
- .returns(JSON.stringify(config));
-
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/foo\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/bar\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/config\.json$/)).returns(true);
-
- cli.exit.withArgs(0).returns(true)
- .withArgs(1).throws(""ProcessExit"");
-
- // Test successful file
- cli.interpret([
- ""node"", ""jshint"", ""foo.js"", ""--config"", ""config.json"", ""--reporter"", ""reporter.js""
- ]);
- test.ok(rep.reporter.args[0][0].length === 0);
-
- // Test overriden, failed file
- cli.interpret([
- ""node"", ""jshint"", ""bar.js"", ""--config"", ""config.json"", ""--reporter"", ""reporter.js""
- ]);
- test.ok(rep.reporter.args[1][0].length > 0, ""Error was expected but not thrown"");
- test.equal(rep.reporter.args[1][0][0].error.code, ""W033"");
-
- test.done();
- },
+#!/bin/bash
+# Create an indexed array
+IndexedArray=(egg burger milk)
+#Iterate over the array to get all the values
+for i in "${IndexedArray[@]}";do echo "$i";done
- testOverridesMatchesRelativePaths: function (test) {
- var dir = __dirname + ""/../examples/"";
- var rep = require(""../examples/reporter.js"");
- var config = {
- ""asi"": true,
- ""overrides"": {
- ""src/bar.js"": {
- ""asi"": false
- }
- }
- };
+A bash script to create and print out an array
- this.sinon.stub(process, ""cwd"").returns(dir);
- this.sinon.stub(rep, ""reporter"");
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/bar\.js$/)).returns(""a()"")
- .withArgs(sinon.match(/config\.json$/))
- .returns(JSON.stringify(config));
+The script iterates over the IndexedArray and prints out all the values.
+9. Conditional Statements
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/bar\.js$/)).returns(true)
- .withArgs(""-e"", sinon.match(/config\.json$/)).returns(true);
+The most popular and widely used conditional statement is if. Even though the if statement is easy to write and understand, it can be used in advanced shell scripts as well.
- cli.exit.withArgs(0).returns(true)
- .withArgs(1).throws(""ProcessExit"");
+Begin with a new bash file:
- cli.interpret([
- ""node"", ""jshint"", ""./src/bar.js"", ""--config"", ""config.json"", ""--reporter"", ""reporter.js""
- ]);
- test.ok(rep.reporter.args[0][0].length === 1);
+nano if.sh
- test.done();
- },
+Paste the code below in it:
- testReporter: function (test) {
- test.expect(5);
-
- var _cli = require(""cli"");
- var rep = require(""../examples/reporter.js"");
- var run = this.sinon.stub(cli, ""run"");
- var out = this.sinon.stub(_cli, ""error"");
- var dir = __dirname + ""/../examples/"";
- this.sinon.stub(process, ""cwd"").returns(dir);
-
- cli.exit.throws(""ProcessExit"");
-
- // Test failed attempt.
- try {
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--reporter"", ""invalid.js""
- ]);
- } catch (err) {
- var msg = out.args[0][0];
- test.equal(msg.slice(0, 25), ""Can't load reporter file:"");
- test.equal(msg.slice(msg.length - 10), ""invalid.js"");
- test.equal(err, ""ProcessExit"");
- }
+#!/bin/bash
+salary=1000
+expenses=800
+#Check if salary and expenses are equal
+if [ $salary == $expenses ];
+then
+ echo "Salary and expenses are equal"
+#Check if salary and expenses are not equal
+elif [ $salary != $expenses ];
+then
+ echo "Salary and expenses are not equal"
+fi
- // Test successful attempt.
- run.restore();
- this.sinon.stub(rep, ""reporter"");
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file\.js$/)).returns(true);
-
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file\.js$/)).returns(""func()"");
-
- try {
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--reporter"", ""reporter.js""
- ]);
- } catch (err) {
- if (err.name !== ""ProcessExit"") {
- throw err;
- }
+This script creates two new variables and compares whether they are equal or not.
+10. Functions
- test.equal(rep.reporter.args[0][0][0].error.raw, ""Missing semicolon."");
- test.ok(rep.reporter.calledOnce);
- }
+A bash function is a set of commands that can be reused numerous times throughout a bash script. Create a new file:
- test.done();
- },
+nano function.sh
- testJSLintReporter: function (test) {
- var rep = require(""../src/reporters/jslint_xml.js"");
- var run = this.sinon.stub(cli, ""run"");
+Then, paste in the following code – it creates a simple Hello World function.
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--reporter"", ""jslint""
- ]);
- test.equal(run.args[0][0].reporter, rep.reporter);
+#!/bin/bash
+hello () {
+ echo 'Hello World!'
+}
+hello
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--jslint-reporter""
- ]);
- test.equal(run.args[1][0].reporter, rep.reporter);
+11. Display String Length
- test.done();
- },
+There are a couple of ways of counting string length in bash. We’ll talk about the simplest. Create a file named stringlength.sh:
- testCheckStyleReporter: function (test) {
- var rep = require(""../src/reporters/checkstyle.js"");
- var run = this.sinon.stub(cli, ""run"");
+nano stringlength.sh
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--reporter"", ""checkstyle""
- ]);
- test.equal(run.args[0][0].reporter, rep.reporter);
+Fill it with the following:
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--checkstyle-reporter""
- ]);
- test.equal(run.args[1][0].reporter, rep.reporter);
+#!/bin/bash
+# Create a new string
+mystring="lets count the length of this string"
+i=${#mystring}
+echo "Length: $i"
- test.done();
- },
+Here, the # operator is used to get the length of the string variable.
+12. Extract String
- testShowNonErrors: function (test) {
- var rep = require(""../src/reporters/non_error.js"");
- var run = this.sinon.stub(cli, ""run"");
+If users need to remove unnecessary parts from strings, they can use the Bash string extraction tools. Start by creating a new bash script:
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--show-non-errors""
- ]);
- test.equal(run.args[0][0].reporter, rep.reporter);
+nano extractstring.sh
- test.done();
- },
+The following script has 4 values, 3 of them being strings. In our example, we will extract only the number value. This can be done via the cut command. First, we instruct the command that each variable is separated by a comma by using the -d flag. Then we ask the cut command to extract the 5th value.
- testExtensions: function (test) {
- var run = this.sinon.stub(cli, ""run"");
+#!/bin/bash
+cut -d , -f 5 <<< "Website,Domain,DNS,SMTP,5005"
- cli.interpret([
- ""node"", ""jshint"", ""file.js""
- ]);
- test.equal(run.args[0][0].extensions, """");
+In another example, we have a string that is mixed with some numbers. We will use expr substr commands to extract only the Hostinger text value.
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--extra-ext"", "".json""
- ]);
- test.equal(run.args[1][0].extensions, "".json"");
+#!/bin/bash
+expr substr "458449Hostinger4132" 7 9
- test.done();
- },
+13. Find and Replace String
- testMalformedNpmFile: function (test) {
- this.sinon.stub(process, ""cwd"").returns(__dirname);
- var localNpm = path.normalize(__dirname + ""/package.json"");
- var localRc = path.normalize(__dirname + ""/.jshintrc"");
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+Another useful bash script for strings is find and replace. Create a file named findreplace.sh:
- // stub rc file
- testStub.withArgs(""-e"", localRc).returns(true);
- catStub.withArgs(localRc).returns('{""evil"": true}');
+nano findreplace.sh
- // stub npm file
- testStub.withArgs(""-e"", localNpm).returns(true);
- catStub.withArgs(localNpm).returns('{'); // malformed package.json
+Then paste in the following bash script:
- // stub src file
- testStub.withArgs(""-e"", sinon.match(/file\.js$/)).returns(true);
- catStub.withArgs(sinon.match(/file\.js$/)).returns(""eval('a=2');"");
+#!/bin/bash
+first="I drive a BMW and Volvo"
+second="Audi"
+echo "${first/BMW/"$second"}"
- cli.interpret([
- ""node"", ""jshint"", ""file.js""
- ]);
- test.equal(cli.exit.args[0][0], 0); // lint with wrong package.json
+Find and replace script in bash
- test.done();
- },
+The find and replace functionality doesn’t require any special commands, it can all be done with string manipulation.
+14. Concatenate Strings
- testRcFile: function (test) {
- this.sinon.stub(process, ""cwd"").returns(__dirname);
- var localRc = path.normalize(__dirname + ""/.jshintrc"");
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+Concatenation is the term used for appending one string to the end of another string. Start by creating concatenation.sh file.
- // stub rc file
- testStub.withArgs(""-e"", localRc).returns(true);
- catStub.withArgs(localRc).returns('{""evil"": true}');
+nano concatenation.sh
- // stub src file
- testStub.withArgs(""-e"", sinon.match(/file\.js$/)).returns(true);
- catStub.withArgs(sinon.match(/file\.js$/)).returns(""eval('a=2');"");
+The most simple example would be the following:
- cli.interpret([
- ""node"", ""jshint"", ""file.js""
- ]);
- test.equal(cli.exit.args[0][0], 0); // eval allowed = rc file found
+#!/bin/bash
+firststring="The secret is..."
+secondstring="Bash"
+thirdstring="$firststring$secondstring"
+echo "$thirdstring"
- test.done();
- },
+The above script will connect the values of firststring and secondstring variables creating a whole new thirdstring.
- testHomeRcFile: function (test) {
- var homeRc = path.join(process.env.HOME || process.env.HOMEPATH, "".jshintrc"");
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+A more advanced example would look like this:
- // stub rc file
- testStub.withArgs(""-e"", homeRc).returns(true);
- catStub.withArgs(homeRc).returns('{""evil"": true}');
+#!/bin/bash
+firststring="The secret is..."
+firststring+="Bash"
+echo "$firststring"
- // stub src file (in root where we are unlikely to find a .jshintrc)
- testStub.withArgs(""-e"", sinon.match(/\/file\.js$/)).returns(true);
- catStub.withArgs(sinon.match(/\/file\.js$/)).returns(""eval('a=2');"");
+The script uses the += operator to join the strings. With this method, you can concatenate strings with only one variable.
+15. Check if a Number is Even or Odd
- cli.interpret([
- ""node"", ""jshint"", ""/file.js""
- ]);
- test.equal(cli.exit.args[0][0], 0); // eval allowed = rc file found
+Odd and even numbers can be easily divided using the if statement and some simple math. Create a file named evenoddnumbers.sh:
- test.done();
- },
+nano evenoddnumbers.sh
- testNoHomeDir: function (test) {
- var prevEnv = {};
+The script uses the read command to read user input and divides it by 2. If the answer is 0, the number is even.
- // Remove all home dirs from env.
- [ 'USERPROFILE', 'HOME', 'HOMEPATH' ].forEach(function (key) {
- prevEnv[key] = process.env[key];
- delete process.env[key];
- });
+#!/bin/bash
+read -p "Enter a number and I will check if its odd or even " mynumber
+if [ $((mynumber%2)) -eq 0 ]
+then
+echo "Your number is even"
+else
+echo "Your number is odd."
+fi
- this.sinon.stub(process, ""cwd"").returns(__dirname);
- var localRc = path.normalize(__dirname + ""/.jshintrc"");
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+16. Generate Factorial of Number
- // stub rc file
- testStub.withArgs(""-e"", localRc).returns(true);
- catStub.withArgs(localRc).returns('{""evil"": true}');
+The factorial of a number is the result of all positive descending integers. For example, the factorial of 5 would be 120:
- // stub src file
- testStub.withArgs(""-e"", sinon.match(/file\.js$/)).returns(true);
- catStub.withArgs(sinon.match(/file\.js$/)).returns(""eval('a=2');"");
+5! = 5*4*3*2*1 = 120
- cli.interpret([
- ""node"", ""jshint"", ""file.js""
- ]);
- test.equal(cli.exit.args[0][0], 0); // eval allowed = rc file found
+Factorial scrips are very useful for users learning about recursion. Start by creating a .sh file executable:
- test.done();
+factorial.sh
- // Restore environemnt
- Object.keys(prevEnv).forEach(function (key) {
- process.env[key] = prevEnv[key];
- });
- },
+The following script will ask the user to enter a number they want to get the factorial of and use a for loop to calculate it.
- testOneLevelRcLookup: function (test) {
- var srcDir = __dirname + ""../src/"";
- var parentRc = path.join(srcDir, "".jshintrc"");
+#!/bin/bash
+echo Enter the number you want to get factorial for
+read mynumber
+factorial=1
+for ((i=1;i<=mynumber;i++))
+do
+factorial=$(($factorial*$i))
+done
+echo $factorial
- var cliDir = path.join(srcDir, ""cli/"");
- this.sinon.stub(process, ""cwd"").returns(cliDir);
+The command-line window displaying shell script for getting factorial of a number
+17. Create Directories
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+It is effortless to create directories in bash unless you need to create a lot of directories quickly. In the following example, we will use the bash script to create a set of directories with the same subdirectories in each.
- // stub rc file
- testStub.withArgs(""-e"", parentRc).returns(true);
- catStub.withArgs(parentRc).returns('{""evil"": true}');
+First, create a file named directories.sh:
- // stub src file
- testStub.withArgs(""-e"", sinon.match(/file\.js$/)).returns(true);
- catStub.withArgs(sinon.match(/file\.js$/)).returns(""eval('a=2');"");
+nano directories.sh
- cli.interpret([
- ""node"", ""jshint"", ""file.js""
- ]);
- test.equal(cli.exit.args[0][0], 0); // eval allowed = rc file found
+Then paste in the following code:
- test.done();
- },
+#!/bin/bash
+mkdir -p {Math,English,Geography,Arts}/{notes,examresults,portfolio}
- testTargetRelativeRcLookup: function (test) {
- // working from outside the project
- this.sinon.stub(process, ""cwd"").returns(process.env.HOME || process.env.HOMEPATH);
- var projectRc = path.normalize(__dirname + ""/.jshintrc"");
- var srcFile = __dirname + ""/sub/file.js"";
- var testStub = this.sinon.stub(shjs, ""test"");
- var catStub = this.sinon.stub(shjs, ""cat"");
+The script creates 4 main directories: Math, English, Geography, and Arts. The Notes, examresults, and portfolio subdirectories are also created inside each.
- // stub rc file
- testStub.withArgs(""-e"", projectRc).returns(true);
- catStub.withArgs(projectRc).returns('{""evil"": true}');
+If you were to replace the / symbol in the middle with _, the script would look like this:
- // stub src file
- testStub.withArgs(""-e"", srcFile).returns(true);
- catStub.withArgs(srcFile).returns(""eval('a=2');"");
+#!/bin/bash
+mkdir -p {Math,English,Geography,Arts}_{notes,examresults,portfolio}
- cli.interpret([
- ""node"", ""jshint"", srcFile
- ]);
- test.equal(cli.exit.args[0][0], 0); // eval allowed = rc file found
+Here’s the output for it displaying a merge of the two directories:
+A bash script to create a lot of directories quickly. The first bash case statement indicates which interpreter to use
- test.done();
- },
+#!/bin/bash
+#Declare string S1
+S1="Bash"
+#Declare string S2
+S2="Scripting"
+if [ $S1 = $S2 ]; then
+ echo "Both Strings are equal"
+else
+ echo "Strings are NOT equal"
+fi
- testIgnores: function (test) {
- var run = this.sinon.stub(cli, ""run"");
- var dir = __dirname + ""/../examples/"";
- this.sinon.stub(process, ""cwd"").returns(dir);
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--exclude=exclude.js""
- ]);
+The following script will check to see if a file exists or not.
- test.equal(run.args[0][0].ignores[0], path.resolve(dir, ""exclude.js""));
- test.equal(run.args[0][0].ignores[1], path.resolve(dir, ""ignored.js""));
- test.equal(run.args[0][0].ignores[2], path.resolve(dir, ""another.js""));
+#!/bin/bash
+file="./file"
+if [ -e $file ]; then
+ echo "File exists"
+else
+ echo "File does not exist"
+fi
- run.restore();
- process.cwd.returns(__dirname + ""/../"");
+The result:
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file.js$/)).returns(""console.log('Hello');"")
- .withArgs(sinon.match(/\.jshintignore$/)).returns(""examples"");
+$ ./filetesting.sh
+File does not exist
+$ touch file
+$ ./filetesting.sh
+File exists
- test.equal(shjs.cat.args.length, 0);
+Similarly for example we can use while loop to check if file does not exist. This script will sleep until file does exist. Note bash negator ! which negates the -e option.
- test.done();
- },
+#!/bin/bash
- testExcludePath: function (test) {
- var run = this.sinon.stub(cli, ""run"");
- var dir = __dirname + ""/../examples/"";
- this.sinon.stub(process, ""cwd"").returns(dir);
+while [ ! -e myfile ]; do
+# Sleep until file does exists/is created
+sleep 1
+done
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""--exclude-path=../examples/.customignore""
- ]);
- test.equal(run.args[0][0].ignores[0], path.resolve(dir, ""exclude.js""));
+Bash Select
- run.restore();
- process.cwd.returns(__dirname + ""/../"");
+The select command allows us to prompt the user to make a selection.
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file.js$/)).returns(""console.log('Hello');"")
- .withArgs(sinon.match(/\.jshintignore$/)).returns(""examples"");
+#!/bin/bash
- test.equal(shjs.cat.args.length, 0);
+PS3='Choose one word: '
- test.done();
- },
+# bash select
+select word in "linux" "bash" "scripting" "tutorial"
+do
+ echo "The word you have selected is: $word"
+# Break, otherwise endless loop
+ break
+done
- testAPIIgnores: function (test) {
- var dir = __dirname + ""/../data/"";
- this.sinon.stub(process, ""cwd"").returns(dir);
- var result = null;
+exit 0
- cli.run({
- args: [dir + ""../tests/unit/fixtures/ignored.js""],
- cwd: dir + ""../tests/unit/fixtures/"",
- reporter: function (results) { result = results; }
- });
+The result:
- test.deepEqual(result, []);
+$ ./select.sh
+1) linux
+2) bash
+3) scripting
+4) tutorial
+Choose one word: 2
+The word you have selected is: bash
- test.done();
- },
+Case statement conditional
- testCollectFiles: function (test) {
- var gather = this.sinon.stub(cli, ""gather"");
- var args = [];
+The case statement makes it easy to have many different possibilities, whereas an if statement can get lengthy very quickly if you have more than a few possibilities to account for.
- gather.returns([]);
+#!/bin/bash
+echo "What is your preferred programming / scripting language"
+echo "1) bash"
+echo "2) perl"
+echo "3) phyton"
+echo "4) c++"
+echo "5) I do not know !"
+read case;
+#simple case bash structure
+# note in this case $case is variable and does not have to
+# be named case this is just an example
+case $case in
+ 1) echo "You selected bash";;
+ 2) echo "You selected perl";;
+ 3) echo "You selected phyton";;
+ 4) echo "You selected c++";;
+ 5) exit
+esac
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/.*/)).returns(true);
+The result:
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file2?\.js$/)).returns(""console.log('Hello');"")
- .withArgs(sinon.match(/ignore[\/\\]file\d\.js$/)).returns(""console.log('Hello, ignore me');"")
- .withArgs(sinon.match(/ignore[\/\\]dir[\/\\]file\d\.js$/)).returns(""print('Ignore me');"")
- .withArgs(sinon.match(/node_script$/)).returns(""console.log('Hello, ignore me');"")
- .withArgs(sinon.match(/\.jshintignore$/)).returns(path.join(""ignore"", ""**""));
+$ ./case.sh
+What is your preferred programming / scripting language
+1) bash
+2) perl
+3) phyton
+4) c++
+5) I do not know !
+3
+You selected phyton
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""file2.js"", ""node_script"", path.join(""ignore"", ""file1.js""),
- path.join(""ignore"", ""file2.js""), path.join(""ignore"", ""dir"", ""file1.js"")
- ]);
+Bash quotes and quotations
- args = gather.args[0][0];
+Quotations and quotes are important part of bash and bash scripting. Here are some bash quotes and quotations basics.
+Escaping Meta characters
- test.equal(args.args[0], ""file.js"");
- test.equal(args.args[1], ""file2.js"");
- test.equal(args.args[2], ""node_script"");
- test.equal(args.args[3], path.join(""ignore"", ""file1.js""));
- test.equal(args.args[4], path.join(""ignore"", ""file2.js""));
- test.equal(args.args[5], path.join(""ignore"", ""dir"", ""file1.js""));
- test.equal(args.ignores, path.resolve(path.join(""ignore"", ""**"")));
+Before we start with quotes and quotations we should know something about escaping meta characters. Escaping will suppress a special meaning of meta characters and therefore meta characters will be read by bash literally. To do this we need to use backslash \ character. Example:
- shjs.cat.restore();
+#!/bin/bash
- shjs.test.withArgs(""-d"", sinon.match(/src$/)).returns(true)
- .withArgs(""-d"", sinon.match(/src[\/\\]lib$/)).returns(true);
+#Declare bash string variable
+BASH_VAR="Bash Script"
- this.sinon.stub(shjs, ""ls"")
- .withArgs(sinon.match(/src$/)).returns([""lib"", ""file4.js""])
- .withArgs(sinon.match(/src[\/\\]lib$/)).returns([""file5.js""]);
+# echo variable BASH_VAR
+echo $BASH_VAR
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/file2?\.js$/)).returns(""console.log('Hello');"")
- .withArgs(sinon.match(/file3\.json$/)).returns(""{}"")
- .withArgs(sinon.match(/src[\/\\]file4\.js$/)).returns(""print('Hello');"")
- .withArgs(sinon.match(/src[\/\\]lib[\/\\]file5\.js$/)).returns(""print('Hello');"")
- .withArgs(sinon.match(/\.jshintignore$/)).returns("""");
+#when meta character such us "$" is escaped with "\" it will be read literally
+echo \$BASH_VAR
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""file2.js"", ""file3.json"", ""--extra-ext=json"", ""src""
- ]);
+# backslash has also special meaning and it can be suppressed with yet another "\"
+echo "\\"
- args = gather.args[1][0];
+Here’s what it looks like when we execute the script:
- test.equal(args.args.length, 4);
- test.equal(args.args[0], ""file.js"");
- test.equal(args.args[1], ""file2.js"");
- test.equal(args.args[2], ""file3.json"");
- test.equal(args.args[3], ""src"");
- test.equal(args.ignores, false);
+$ ./escape_meta.sh
+Bash Script
+$BASH_VAR
+\
- shjs.cat
- .withArgs(sinon.match(/reporter\.js$/)).returns(""console.log('Hello');"");
+Single quotes
- cli.interpret([
- ""node"", ""jshint"", ""examples""
- ]);
+Single quotes in bash will suppress special meaning of every meta characters. Therefore meta characters will be read literally. It is not possible to use another single quote within two single quotes not even if the single quote is escaped by backslash.
- args = gather.args[2][0];
+#!/bin/bash
- test.equal(args.args.length, 1);
- test.equal(args.args[0], ""examples"");
- test.equal(args.ignores.length, 0);
+# Declare bash string variable
+BASH_VAR="Bash Script"
- test.done();
- },
+# echo variable BASH_VAR
+echo $BASH_VAR
- testGatherOptionalParameters: function (test) {
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/file.js$/)).returns(true);
+# meta characters special meaning in bash is suppressed when using single quotes
+echo '$BASH_VAR "$BASH_VAR"'
- var files = cli.gather({
- args: [""file.js""]
- });
+The result:
- test.equal(files.length, 1);
- test.equal(files[0], ""file.js"");
+$ ./single_quotes.sh
+Bash Script
+$BASH_VAR "$BASH_VAR"
- test.done();
- },
+Double quotes
- testGather: function (test) {
- var dir = __dirname + ""/../examples/"";
- var files = [];
- this.sinon.stub(process, ""cwd"").returns(dir);
-
- var demoFiles = [
- [ /file2?\.js$/, ""console.log('Hello');"" ],
- [ /ignore[\/\\]file\d\.js$/, ""console.log('Hello, ignore me');"" ],
- [ /ignore[\/\\]dir[\/\\]file\d\.js$/, ""print('Ignore me');"" ],
- [ /node_script$/, ""console.log('Hello, ignore me');"" ]
- ];
-
- var testStub = this.sinon.stub(shjs, ""test"");
- demoFiles.forEach(function (file) {
- testStub = testStub.withArgs(""-e"", sinon.match(file[0])).returns(true);
- });
-
- var catStub = this.sinon.stub(shjs, ""cat"");
- demoFiles.forEach(function (file) {
- catStub = catStub.withArgs(sinon.match(file[0])).returns(file[1]);
- });
-
- files = cli.gather({
- args: [""file.js"", ""file2.js"", ""node_script"",
- path.join(""ignore"", ""file1.js""),
- path.join(""ignore"", ""file2.js""),
- path.join(""ignore"", ""dir"", ""file1.js"")
- ],
- ignores: [path.join(""ignore"", ""**"")],
- extensions: """"
- });
-
- test.equal(shjs.cat.args.length, 0);
- test.equal(files.length, 3);
- test.equal(files[0], ""file.js"");
- test.equal(files[1], ""file2.js"");
- test.equal(files[2], ""node_script"");
-
- demoFiles = [
- [ /file2?\.js$/, ""console.log('Hello');"" ],
- [ /file3\.json$/, ""{}"" ],
- [ /src[\/\\]file4\.js$/, ""print('Hello');"" ],
- [ /src[\/\\]lib[\/\\]file5\.js$/, ""print('Hello'); ""]
- ];
-
- demoFiles.forEach(function (file) {
- testStub = testStub.withArgs(""-e"", sinon.match(file[0])).returns(true);
- });
-
- testStub = testStub
- .withArgs(""-e"", sinon.match(/src$/)).returns(true)
- .withArgs(""-e"", sinon.match(/src[\/\\]lib$/)).returns(true)
- .withArgs(""-d"", sinon.match(/src$/)).returns(true)
- .withArgs(""-d"", sinon.match(/src[\/\\]lib$/)).returns(true);
-
- this.sinon.stub(shjs, ""ls"")
- .withArgs(sinon.match(/src$/)).returns([""lib"", ""file4.js""])
- .withArgs(sinon.match(/src[\/\\]lib$/)).returns([""file5.js""]);
-
- demoFiles.forEach(function (file) {
- catStub = catStub.withArgs(sinon.match(file[0])).returns(file[1]);
- });
-
- cli.interpret([
- ""node"", ""jshint"", ""file.js"", ""file2.js"", ""file3.json"", ""--extra-ext=json"", ""src""
- ]);
-
- files = cli.gather({
- args: [""file.js"", ""file2.js"", ""file3.json"", ""src""],
- extensions: ""json"",
- ignores: []
- });
-
- test.equal(shjs.cat.args.length, 5);
- test.equal(files.length, 5);
- test.equal(files[0], ""file.js"");
- test.equal(files[1], ""file2.js"");
- test.equal(files[2], ""file3.json"");
- test.equal(files[3], path.join(""src"", ""lib"", ""file5.js""));
- test.equal(files[4], path.join(""src"", ""file4.js""));
-
- shjs.test.restore();
- shjs.ls.restore();
- shjs.cat.restore();
- process.cwd.restore();
-
- this.sinon.stub(process, ""cwd"").returns(__dirname + ""/../"");
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/reporter\.js$/)).returns(""console.log('Hello');"");
-
- files = cli.gather({
- args: [""examples""],
- extensions: ""json"",
- ignores: []
- });
-
- test.equal(shjs.cat.args.length, 0);
- test.equal(files.length, 1);
- test.equal(files[0], path.join(""examples"", ""reporter.js""));
-
- test.done();
- },
+Double quotes in bash will suppress special meaning of every meta characters except $, \ and `. Any other meta characters will be read literally. It is also possible to use single quote within double quotes. If we need to use double quotes within double quotes bash can read them literally when escaping them with \. Example:
- testStatusCode: function (test) {
- var rep = require(""../examples/reporter.js"");
- var dir = __dirname + ""/../examples/"";
- this.sinon.stub(rep, ""reporter"");
- this.sinon.stub(process, ""cwd"").returns(dir);
+#!/bin/bash
- this.sinon.stub(shjs, ""test"")
- .withArgs(""-e"", sinon.match(/(pass\.js|fail\.js)$/)).returns(true);
+#Declare bash string variable
+BASH_VAR="Bash Script"
- this.sinon.stub(shjs, ""cat"")
- .withArgs(sinon.match(/pass\.js$/)).returns(""function test() { return 0; }"")
- .withArgs(sinon.match(/fail\.js$/)).returns(""console.log('Hello')"");
+# echo variable BASH_VAR
+echo $BASH_VAR
- cli.interpret([
- ""node"", ""jshint"", ""pass.js"", ""--reporter=reporter.js""
- ]);
+# meta characters and its special meaning in bash is
+# suppressed when using double quotes except "$", "\" and "`"
- cli.interpret([
- ""node"", ""jshint"", ""fail.js"", ""--reporter=reporter.js""
- ]);
+echo "It's $BASH_VAR and \"$BASH_VAR\" using backticks: `date`"
- test.strictEqual(cli.exit.args[0][0], 0);
- test.equal(cli.exit.args[1][0], 2);
+The result:
- test.done();
- }
-};
+$ ./double_quotes.sh
+Bash Script
+It's Bash Script and "Bash Script" using backticks: Thu 10 Feb 2022 10:24:15 PM EST
+
+Bash quoting with ANSI-C style
+
+There is also another type of quoting and that is ANSI-C. In this type of quoting characters escaped with \ will gain special meaning according to the ANSI-C standard.
+\a alert (bell) \b backspace
+\e an escape character \f form feed
+\n newline \r carriage return
+\t horizontal tab \v vertical tab
+\\ backslash \` single quote
+\nnn octal value of characters ( see [http://www.asciitable.com/ ASCII table] ) \xnn hexadecimal value of characters ( see [http://www.asciitable.com/ ASCII table] )